Java中synchronized关键字

synchronized可以用来修饰方法作为同步方法，也可以构成同步代码块。

同步代码块格式:

    

     synchronized(锁对象){
                     针对多条语句对共享数据操作代码;
             }

     锁对象:肯定一个对象,随便创建一个对象(匿名对象)
                    给刚才的这个程序加入了同步代码块,但是锁对象使用的匿名对象(每一个线程进来都有自己的锁),还是没有解决!
     锁对象:每一个线程最总使用的锁对象,只能是同一把锁（每一个锁对象代表一把锁子）

程序示例

public class SellTicket implements Runnable {    
    //定义100张票
    private int tickets = 100 ;    
    private Object obj = new Object() ; //定义一个锁对象，每一个锁对象代表一个锁）
    @Override
    public void run() {
        while(true) {
                    
            synchronized(obj) {//第一个线程进来,门一关,后面的线程就进不来了
                if(tickets>0) {
                    try {
                        //睡眠:延迟
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            +"正在出售第"+(tickets--)+"张票");//0,-1
                }
            }
            
        }
    }
}

同步方法：

非静态的方法:同步方法(需要底层源码,一些方法会声明synchronized)的锁对象:this

private synchronized  void sellTicket() {
            if(tickets>0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()
                        +"正在出售第"+(tickets--)+"张票");
            }
        }

静态的同步方法:和反射有关 (静态同步方法的锁对象:类名.class)

private synchronized  void sellTicket() {
            if(tickets>0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()
                        +"正在出售第"+(tickets--)+"张票");
            }
        }

      同步方法直接在方法上加synchronized实现加锁，同步代码块则在方法内部加锁，很明显，同步方法锁的范围比较大，而同步代码块范围要小点，一般同步的范围越大，性能就越差，一般需要加锁进行同步的时候，肯定是范围越小越好，这样性能更好。

什么是监视器

监视器可以看做是经过特殊布置的建筑，这个建筑有一个特殊的房间，该房间通常包含一些数据和代码，但是一次只能一个消费者(thread)使用此房间

synchronized(this)同步代码块
1）对其它的synchronized同步方法或synchronized(this)同步代码块调用是堵塞状态；
2）同一时间只有一个线程执行synchronized同步方法中的代码。

使用 synchronized(任意自定义对象)进行同步操作，对象监视器必须是同一个对象。不过不是同一个，运行就是异步执行了。

同步synchronized(*.class)代码块的作用其实和synchronized static方法作用一样。Class锁对类的所有对象实例起作用。

使用synchronized可能会出现死锁

同一时间内只能只有一个线程可以操作synchronized中的代码，所以可能会出现死锁，下面的代码可能出现永远执行不完的情况。

DieLock dl1 = new DieLock(true) ;
DieLock dl2 = new DieLock(false) ;
        
//启动线程
dl1.start();
dl2.start();

public void run() {
    if(flag) {
        synchronized (锁1) {//只有代码执行完毕、break，return中断或者出现错误才有可能释放锁
            System.out.println("if ObjA");
                synchronized (锁2) {//等待下面的锁2执行完毕，同一时间只能有一个线程操作锁
                    System.out.println("if objB");
                }
        }
    }else {
        synchronized (锁2) {
            System.out.println("else objB");
                synchronized (锁1) {//等待上面的锁1执行完毕
                    System.out.println("else objA");
                }
        }    
    }
}