多 线程

wait 释放锁（需配合synchronize使用）（wait 的缺点是一直在等待询问，导致性能低下。可以采用CountDownLantch 这个类的countDown()方法来解决这个问题）

notify 不释放锁（也就是说，调用notify()的时候，该线程还没释放锁，而是在该线程执行完后，才会释放这把锁）（需配合synchronize使用）

synchronize：同步锁

volatile：线程间通讯的修饰符

 CountDownLatch ：用于实时通知的类（countDownLath.countDown(1)--这个1表示得执行多少次，await()才会唤醒、countDown.await() ，不需要配合synchronize使用）

-----------------------------

可重入锁：重进入是指任意线程在获取到锁之后，再次获取该锁而不会被该锁所阻塞。代码如下

 public synchronized void service1(){
        System.out.println("进入锁1");
        //service1的锁还没释放，就执行了service()2，证明锁是可重入的。因为，这是统一把锁
        service2();
        System.out.println("进入锁11");
    }

    public synchronized void service2(){
        System.out.println("进入锁2");
        service3();
        System.out.println("进入锁22");
    }
    public synchronized void service3(){
        System.out.println("进入锁3");
    }

父类方法同步，子类重写该方法（没有synchronized关键字修饰），是没有同步作用的。

不同的锁没有互斥作用，代码如下：

class Service2 
    {
        Strign s=new String();
        public  void service(char name)
        {
            
            synchronized(s)            //这里锁住的是s对象
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
        public void service2(char name)      
        {
            synchronized(this)  {           //这里锁住的是this对象
                for (int i = 6; i >3; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
    }

synchronized方法和synchronized(this)代码块是锁定当前对象的（效果是一样的），代码如下：

public  void service(char name)
        {
            
            synchronized(this)
                {
                for (int i = 3; i >0; i--) {
                    System.out.println(name+":"+i);
                }
            }
        }
public synchronized void service2(char name)
        {
                for (int i = 6; i >3; i--) {
                    System.out.println(name+":"+i);
                }
        }

一个对象中的不同同步代码块是互斥的，执行完一个代码块再执行另一个代码块

syncronized static 同步静态方法，锁住的是Class对象（就是Class对象，没写错）

volatile对比synchronized

• volitate增加了实例变量在对个线程之间的可见性，保证我们获得的是变量的最新值。
• volatile在读上面保持了同步作用，但是在写上面不保持同步
• synchronized的同步作用不仅保证了对同一个锁线程的互斥，还保证了数据的同步

 -----------------------------------------------

CycliBarrire（循环障碍）        ---场景：多个运动员比赛，只有所有运动员都准备好才能开始  ---多个线程都在阻塞

CoutDownLatch                      ---计时器 --一个线程等待（阻塞），多个线程通知他。

-----------------------------------------------------------------------

Excutor 的submit()和excute()方法的区别：

1、submit()可以传入实现了Callable的接口的类，也可以是实现了Runnable接口的类；而excute()只能传入实现了Runnable接口的类

2、submit()有返回值

----------------------------------------------

Lock 锁，包括重入锁（ReenTrantLock）、读锁（ReadLock）、写锁（WriteLock）