(六) synchronized关键字

Java多线程目录

1 synchronized是什么

synchronized是Java在并发编程中的一个中要关键字，在并发编程中我们会遇到线程安全问题，synchronized就像是一把锁，而打开这把锁的钥匙只能一个线程持有，这样线程中共享变量的访问每次都会只有一个线程进行操作，这样就不会存在线程安全的问题。
synchronized执行时会在进入代码处获得锁，离开synchronized修饰的代码释放锁。

2 synchronized的使用

synchronized同步锁使用主要有一下几个方面:

1. 使用在代码块上。
2. 使用在普通方法上。
3. 使用在静态方法上。
4. 使用在类上。

2.1 修饰代码块

synchronized修改代码块的结构是

public void test(){
  synchronized(param){
    //TODO
  }
}

synchronized的锁是加在那，取决于它后面的参数param，如果param是this,这个锁就是加载这个对象上的，如果是其他的的对象，则这个锁是加在其他对象上的。

public class ThreadOne implements Runnable {

    int i = 0;
    private Object object = new Object();

    public void run() {
        test();
        test2();
    }

    public void test() {
        synchronized (this) {
            i++;
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public void test2() {
        synchronized (object) {
            i++;
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        ThreadOne one = new ThreadOne();
        for (int i = 1; i < 100; i++) {
            new Thread(one, "" + i).start();
        }
    }
}

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

public class ThreadOne extends Thread {

    int i = 0;
    private Object object = new Object();

    @Override
    public void run() {
        super.run();
        test();
        test2();
    }

    public void test() {
        synchronized (this) {
            i++;
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public void test2() {
        synchronized (object) {
            i++;
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }


    public static void main(String[] args) {
        for (int i = 1; i < 1000; i++) {
            new ThreadOne( ).start();
        }
    }
}

上面两个例子可以猜出结果，第二个例子是无法得到正确结果的，因为synchronized的加锁是加在后面参数param上的，所以第一个例子他的锁加载this, object上，这里这个程序中this指ThreadOne, object是ThreadOne类对象中的一个成员变量，这里ThreadOne都是同一个对象，所以锁加在的对象也就只有一个。第二个例子是每次新建了一个ThreadOne类对象，一个ThreadOne对象中一个Object成员变量，这样其实synchronized加的锁都加在了不同的对象上，所以无法达到我们的预期。

2.2 修饰普通方法

    public synchronized void test() {
        //todo
    }

注意synchronized获得的是当前的对象锁，与synchronized(this)语义相同。多个线程对同一个对象的同步方法访问会竞争这个对象锁，每次只能有一个线程访问这个方法。

2.3 直接加类锁

上面synchronized(this)修饰的这个类的对象的锁，如果我们使用

synchronized(ThreadOne.class){}

则上面这个是类的锁，类锁表示的意思是这个锁对这个类的所有的对象都适用。当多个线程适用这个类时，不管有多少个对象，这里都是同步代码块，都只允许一个线程访问。

修饰静态方法。

//与普通方法使用一样。
public static synchronized test(){
}

修饰讲台方法时这个锁是类锁，也就是说这个静态方法的同步调用是依据的这个类，而不是这个类的类对象。

3 分类

上面介绍了总计下来synchronized分为类对象锁和类锁，

1. 类对象锁: 锁加到的是类的对象实例，多个线程同时访问同一个对象实例的同步方法时synchronized起作用
2. 类锁： 类锁是加在类class上的，对该类的所有对象都适用，多线程访问多个该类对象实例的同步方法这个synchronized起作用。