synchronized和volatile关键字

一、synchronized

1. 起到的作用：保证 操作的原子性，禁止指令重排序，确保内存访问的可见性。
2. 适用于多个线程的写操作，也用于一个线程写操作，一个线程读操作。
就相当于给操作多加了LOCK（加锁）和UNLOCK（解锁）两个指令。

如果两个线程竞争同一个锁对象（尝试对同一个对象进行加锁，此时就会出现一个竞争成功，其他等待的情况）。
如果两个线程竞争不同的锁，两个线程都能成功获取到锁。
进行加锁操作就必须明确这个锁针对“哪个对象”加的，到底这个锁能不能竞争成功。

通过LOCK和UNLOCK两个指令将其他一些指令打包成一个原子操作（中间不能被打断，也不能被其他线程穿插）。
3. 用法一：修饰一个方法

synchronized public void increase(){//进入代码块就加锁
     count++;
}									//结束代码块就解锁
//在方法前加上synchronized即可

4. 用法二：修饰一个代码块

public void increase(){
     count++;
}
Counter counter=new Counter();
        Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i=0;i<50000;i++){
                //在代码块中执行
                    synchronized (counter){//()中针对那个对象加锁，就填写那个对象
                        counter.increase();
                    }
                }
            }
        };
        Thread t2=new Thread(){
            @Override
            public void run() {
                for (int i=0;i<50000;i++){
                //在代码块中执行
                    synchronized (counter){
                        counter.increase();
                    }
                }
            }
        };
        t1.start();
        t2.start();

5. 如果嵌套执行synchronized会出现怎样的情况？
答：会产生 死锁 ，但是synchronized使用了特殊的手段来处理这个场景。（可重入锁）

二、volatile

1.起到的作用：保证线程的安全。禁止指令的重排序和确保内存访问的可见性。但是不能保证原子性。
2.适用于一个线程写，一个线程读的情况下。（同一个变量）

下面是展示 代码。

	static class Counter{
        volatile public int flag=0;
    }
    public static void main(String[] args) {
        Counter counter=new Counter();
        Thread t1=new Thread(){
            @Override
            public void run() {
                while(counter.flag==0){
                    //do nothing
                }
                System.out.println("线程1循环结束");
            }
            
        };
        t1.start();

        Thread t2=new Thread(){
            @Override
            public void run() {
                Scanner scanner=new Scanner(System.in);
                System.out.println("请输入一个整数：");
                counter.flag=scanner.nextInt();
            }
        };
        t2.start();
    }

run（）循环执行的速度很快，此时就需要CPU频繁的读取内存的数据（读取内存的数据要比读取寄存器的数据满很多），然后编译器就会进行优化，就会只从内存（主内存）中读取一次，然后都直接读寄存器/缓存（工作内存）里的内容。
因此在写成volatile public int flag=0;就会强制每次都会从内存中读取数据，而不是寄存器/缓存中读取数据了。

三、synchronized和volatile关键字的比较

1. volatile要比synchronized更加的轻量，更加的高效（因为不涉及到锁的竞争，不涉及到线程的调度）。
2. 如果两个线程都要涉及到写操作的话就必须使用synchronized了。

四、等待对象集 wait()和notify()

1. wait()（等待）和notify()（唤醒）必须要在synchronized里执行。
2. 如果不在synchronized里面执行就会产生异常。

Monitor指的是监视器锁，也就是synchronized，当前预期是获取到锁的状态才可以调用wait()，如多没写synchronized相当于还没获取到锁，就尝试调用，于是就会异常。
3. wait()内部做了三件事：

• 释放锁
• 等待其他线程的通知
• 等通知来了以后，重新尝试获取锁

4. notify():调用notify()方法后并不会立即释放锁，而是在执行万当前的synchronized之后才进行释放，同时等待中的线程就会重新尝试竞争这个锁。