Java关键词Synchronized关键词

知识点如下

synchronized同步方法

Java的synchronized关键字：同步机制总结
1. Synchronized关键词不管是加在方法上还是对象上，他取得的锁都是对象，而不是把一段代码或函数当做锁。同步的方法很可能还会被其他线程的对象访问。
2. 每个对象只有一个锁（lock）与之关联。
3. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

设有有Object1、Object2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法。
Object1、Object2都能够调用他们。

情况1：

public synchronized void method(){
//...
}

这也就是同步方法，那这是synchronized锁定的对象是调用这个同步方法的对象。如果对象Object在不同到的线程中执行这个同步方法时，他们之间形成互斥，达到同步的效果。
示例代码：

public void test(){//方法没有同步关键词synchronized关键词
            int i = 5;
            while(i-- > 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
                try{
                    Thread.sleep(500);
                }catch (InterruptedException ie){
                }
            }
        }

测试代码如下：

public static void main(String[] args){
        final TestSynchronized object1 = new TestSynchronized();
        Thread test1 = new Thread(new Runnable() {
            @Override
            public void run() {
            //线程1调用object1
                object1.test();
            }
        },"test1");

        Thread test2 = new Thread(new Runnable() {
            @Override
            public void run() {
            //线程2调用object1
                object1.test();
            }
        },"test2");

        test1.start();
        test2.start();
    }

输出（线程1和线程2并没有互斥，线程1和线程2交替输出）：
test2:4
test1:4
test2:3
test1:3
test1:2
test2:2
test1:1
test2:1
test2:0
test1:0

如果在方法test()前面加上synchronized关键词的话，同样的测试代码运行的结果如下（线程test1调用object1，线程test2也调用object1）,两个线程调用同一个对象，当test1持有object1的对象锁的时候，test2只能等待，test1释放了object1的对象锁的时候，test2才能持有object1的对象锁，所以结果如下：
test1:4
test1:3
test1:2
test1:1
test1:0
test2:4
test2:3
test2:2
test2:1
test2:0

等同与下面代码：

public  void test() {
        synchronized (this) {
      //...
        }
    }

这里的this指的是什么呢，他指的就是调用这个方法的对象，如object1。同步方法实质是指将synchd作用于object reference.那个拿到了object1对象锁的线程，才能调用object1的同步放大，而对于object2而言，object1这个锁和他没有关系，程序也可能在这种情况下摆脱同步机制的控制，造成数据的混乱。
如果修改测试代码如下：

public static void main(String[] args){
        final TestSynchronized object1 = new TestSynchronized();
        final TestSynchronized object2 = new TestSynchronized();
        Thread test1 = new Thread(new Runnable() {
            @Override
            public void run() {
                object1.test();
            }
        },"test1");

        Thread test2 = new Thread(new Runnable() {
            @Override
            public void run() {
                object2.test();
            }
        },"test2");

        test1.start();
        test2.start();
    }

输出如下（可以看到线程1、线程2并不是互斥的）：
test2:4
test1:4
test1:3
test2:3
test2:2
test1:2
test2:1
test1:1
test2:0
test1:0

synchronized同步块：

public void method(Object o) {
synchronized(o)
{
//…..
}
}

这个时候锁就是o这个对象。当有一个明确的对象作为锁的时候，就能够这些写，但当没有明确的对象作为锁，只是想让一段代码同步时，能够创建一个特别的instance变量（对象）来充当锁。

将Synchronized作用于static函数

public  static synchronized void test2(){
        int i = 5;
        while(i-- > 0){
            System.out.println(Thread.currentThread().getName() + ":" + i);
            try{
                Thread.sleep(500);
            }catch(InterruptedException ie){

            }
        }
    }

测试代码如下：

public static void main(String[] args){
        final TestSynchronized object1 = new TestSynchronized();
        final TestSynchronized object2 = new TestSynchronized();
        Thread test1 = new Thread(new Runnable() {
            @Override
            public void run() {
                TestSynchronized.test2();
            }
        },"test1");
        Thread test2 = new Thread(new Runnable() {
            @Override
            public void run() {
                TestSynchronized.test2();
            }
        },"test2");

        test1.start();
        test2.start();
    }

输出结果如下：
test1:4
test1:3
test1:2
test1:1
test1:0
test2:4
test2:3
test2:2
test2:1
test2:0

从打印结果我们可以看到确实获取了TestSynchronized这个类作为锁。
上面的方法与下面的效果类似：

public  void test() {
        synchronized (TestSynchronized.class) {
   //...
   }
}

都是获取TestSynchronized这个类的锁，进行同步。

另外我们第二种方法中修改测试代码：

public static void main(String[] args){
        final TestSynchronized object1 = new TestSynchronized();
        final TestSynchronized object2 = new TestSynchronized();
        Thread test1 = new Thread(new Runnable() {
            @Override
            public void run() {
                object1.test2();
            }
        },"test1");

        Thread test2 = new Thread(new Runnable() {
            @Override
            public void run() {
                object2.test2();
            }
        },"test2");

        test1.start();
        test2.start();
    }

测试结果：
test2:4
test2:3
test2:2
test2:1
test2:0
test1:4
test1:3
test1:2
test1:1
test1:0
现在用不同的对象object 1和object2去调用synchronized修饰的类名的方法，因为现在锁不是加在对象上，而是加在类上，所以还是可以同步互斥。
那么下面这种情况呢：

public  void test() {
        synchronized (this) {//同步代码块，传入的对象实例是this，表明是当前对象。
            int i = 5;
            while (i-- > 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException ie) {

                }
            }
        }
    }
    //}

    public  static synchronized void test2(){//因为第一个同步代码块传入的this,
        int i = 5;
        while(i-- > 0){
            System.out.println(Thread.currentThread().getName() + ":" + i);
            try{
                Thread.sleep(500);
            }catch(InterruptedException ie){

            }
        }
    }

test()方法对调用这个方法的对象加锁，test2作为static函数，对这个TestSynchronized类加锁：
测试代码（同一个对象Object在不同线程中调用不同方法）：

public static void main(String[] args){
        final TestSynchronized object1 = new TestSynchronized();
        final TestSynchronized object2 = new TestSynchronized();
        Thread test1 = new Thread(new Runnable() {
            @Override
            public void run() {
                object1.test();
            }
        },"test1");

        Thread test2 = new Thread(new Runnable() {
            @Override
            public void run() {
                object1.test2();
            }
        },"test2");

        test1.start();
        test2.start();
    }

输出结果：

test2:4
test1:4
test2:3
test1:3
test2:2
test1:2
test2:1
test1:1
test2:0
test1:0
两个线程并不互斥，因为一个是对象锁，一个是类锁，本身锁就不同。

知识点：

  1. 对象锁
  2. 类锁
  3. 不同的线程调用同一个加锁的对象—互斥；
  4. 不同的线程调用不同加锁对象—不互斥。