synchronized关键字详解

一、synchronized关键字介绍

由于synchronized关键字的介绍涉及到锁的相关概念，下面我们先简单介绍下锁相关的一些知识。

java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，知道线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的

synchronized可以同步代码块，给静态方法或者指定class对象加锁，被称为类锁。给非静态方法和代码块加锁被称为对象锁。

虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。

二、synchronized的使用

1.对象锁示例

public class SyncThreading implements Runnable{
    private int count;

    public SyncThreading(){
        count = 0;
    }

    public void run() {
        synchronized (this){ //对象锁
            try {
                for(int i = 0;i<5;i++){
                    System.out.println(Thread.currentThread().getName() + " : " + (count++));
                    Thread.sleep(500);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //test1
//        SyncThreading syncThreading1 = new SyncThreading();
//        SyncThreading syncThreading2 = new SyncThreading();
//        Thread t1 = new Thread(syncThreading1);
//        Thread t2 = new Thread(syncThreading2);

        //test2
        SyncThreading syncThreading = new SyncThreading();
        Thread t1 = new Thread(syncThreading);
        Thread t2 = new Thread(syncThreading);

        t1.start();
        t2.start();
    }
}

test1:输出
Thread-0 : 0
Thread-1 : 0
Thread-0 : 1
Thread-1 : 1
Thread-1 : 2
Thread-0 : 2
Thread-0 : 3
Thread-1 : 3
Thread-1 : 4
Thread-0 : 4

test2:输出
Thread-0 : 0
Thread-0 : 1
Thread-0 : 2
Thread-0 : 3
Thread-0 : 4
Thread-1 : 5
Thread-1 : 6
Thread-1 : 7
Thread-1 : 8
Thread-1 : 9

2.类锁示例

public class SyncThreading implements Runnable{
    private static int count;

    public SyncThreading(){
        count = 0;
    }

    public synchronized static void method(){ //类锁
            try {
                for(int i = 0;i<5;i++){
                    System.out.println(Thread.currentThread().getName() + " : " + (count++));
                    Thread.sleep(500);
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }
    }

    public void run() {
        method();
    }

    public static void main(String[] args) {
        SyncThreading syncThreading1 = new SyncThreading();
        SyncThreading syncThreading2 = new SyncThreading();
        Thread t1 = new Thread(syncThreading1);
        Thread t2 = new Thread(syncThreading2);

        t1.start();
        t2.start();
    }
}

输出：
Thread-0 : 0
Thread-0 : 1
Thread-0 : 2
Thread-0 : 3
Thread-0 : 4
Thread-1 : 5
Thread-1 : 6
Thread-1 : 7
Thread-1 : 8
Thread-1 : 9

synchronized 同步的缺点
synchronized关键字同步的时候，等待的线程将无法控制，只能死等。
synchronized关键字同步的时候，不保证公平性，因此会有线程插队的现象。