synchronized为java中的关键字，用于保证多线程并发时，在同一时刻最多只有一个线程执行该段代码。

包括两种用法：synchronized 方法和 synchronized 块。

第一个Demo

public class ThreadTest extends Thread {   
    private int threadNo;   
    public ThreadTest(int threadNo) {   
        this.threadNo = threadNo;   
    }   
    public static void main(String[] args) throws Exception {   
        for (int i = 1; i < 10; i++) {   
           new ThreadTest(i).start();   
            Thread.sleep(1);   
        }   
     }   
    
    @Override  
     public synchronized void run() {   
        for (int i = 1; i < 100; i++) {   
            System.out.println("No." + threadNo + ":" + i);   
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }   
     }   
 }  

执行结果

No.1:1
No.2:1
No.3:1
No.4:1
No.5:1
No.6:1
No.7:1
No.8:1
No.9:1……..

很显然并没有实现同步操作，代码中在run()方法上面加了synchronized关键字，那为什么没有实现同步呢

首先明确一点，对于一个成员方法加synchronized关键字，这实际上是以这个成员方法所在的对象本身作为对象锁。

这段代码其实就是以ThreadTest类的一个具体对象作为对象锁的。一共十个线程，每个线程持有自己线程对象的那个对象锁。这必然不能产生同步的效果

第二个Demo

public class ThreadTest2 extends Thread{
    private int threadNo; 
    private String lock = "lock";
    public ThreadTest2(int threadNo) {   
        this.threadNo = threadNo;   
    }   
    public static void main(String[] args) throws Exception {   
        for (int i = 1; i < 10; i++) {   
           new ThreadTest2(i).start();   
            Thread.sleep(1);   
        }   
     }   
    
    @Override  
     public  void run() {  
        synchronized (lock) {
             for (int i = 1; i < 100; i++) {   
                    System.out.println("No." + threadNo + ":" + i);   
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }   
        }
     }   
}

执行结果

No.1:1
No.1:2
No.1:3
No.1:4
No.1:5
No.1:6
No.1:7
No.1:8
No.1:9……

很显然这段代码实现了同步,在run()方法中使用了同步代码块，并且以“lock”作为锁

以一个String类型的对象为锁，根据Java方法的传值特点，lock为同一个String对象，所以该对象锁是共享且唯一的

第三个Demo

public class ThreadTest3 extends Thread{
    private int threadNo;   
    public ThreadTest3(int threadNo) {   
        this.threadNo = threadNo;   
    }   
    public static void main(String[] args) throws Exception {   
        for (int i = 1; i < 10; i++) {   
           new ThreadTest3(i).start();   
            Thread.sleep(1);   
        }   
     }   
    
     public static synchronized void dowork(int threadNo) {   
        for (int i = 1; i < 100; i++) {   
            System.out.println("No." + threadNo + ":" + i);   
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }   
     } 
     
     @Override
    public void run() {
        dowork(threadNo);
    }    
}

执行结果

No.1:1
No.1:2
No.1:3
No.1:4
No.1:5
No.1:6
No.1:7
No.1:8…………

很显然这段代码也实现了同步~ 他和第一个demo一样是把synchronized关键字放在方法上面，唯一的不一样就是，dowork方法使用了static关键字修饰

由于在JVM中，所有被加载的类都有唯一的类对象

对于同步静态方法，对象锁就是该静态放发所在的类的Class对象，唯一的 ThreadTest3.class对象

虽然在main方法中创建了该类的多个实例，但是它的类对象只有一个，所以对象锁是共享且唯一的

总结

1、 对于同步的方法或者代码块来说，必须获得对象锁才能够进入同步方法或者代码块进行操作；

2、 如果采用method级别的同步，则对象锁即为method所在的对象，如果是静态方法，对象锁即指method所在的
Class对象(唯一)；

3、 对于代码块，对象锁即指synchronized(abc)中的abc；

4、 静态方法则一定会同步，非静态方法需在单例模式才生效，推荐用静态方法

顺便说一下：

Java中多线程锁释放的条件：

1、执行完同步代码块，就会释放锁。（synchronized）

2、在执行同步代码块的过程中，遇到异常而导致线程终止，锁也会被释放。（exception）

3、在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放锁，进入对象的等待池。(wait)