Java多线程之synchronized关键字

一、synchronized锁住的不是代码块，是对象。

/**
 * synchronized 对某个对象加锁
 */
public class SynchronizedTest {

    private int count = 10;
    private Object o = new Object();

    private void method() {
        synchronized (o) { //任何线程想执行下面这段代码都需要拿到o这把锁
            count--;
            System.out.println(Thread.currentThread().getName() + " count=" + count);
        }
    }

}

二、synchronized是可重入的。

import java.util.concurrent.TimeUnit;

/**
 * 一个同步方法可以调用另外一个同步方法，一个线程已经拥有了某个对象锁，再次申请仍然会得到这把锁。
 * 也就是说synchronized是可重入的。
 */
public class SynchronizedTest3 {

    synchronized void m1() {
        System.out.println(Thread.currentThread().getName() + " m1 start ...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        m2();
        System.out.println(Thread.currentThread().getName() + " m1 end ...");
    }

    synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + " m2 start ...");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " m2 end ...");
    }

    public static void main(String[] args) {

        SynchronizedTest3 test = new SynchronizedTest3();
        new Thread(() -> {
            test.m1();
        }, "t1").start();
        new Thread(() -> {
            test.m2();
        }, "t2").start();

    }

}

三、子类同步方法调用父类同步方法，这是可以的。

import java.util.concurrent.TimeUnit;

/**
 * 子类调用父类同步方法，这是可以的
 */
public class SynchronizedTest5 {

    public static void main(String[] args) {

        Chinese chinese = new Chinese();
        chinese.m();

    }

    static class Person {
        synchronized void m() {
            System.out.println("m start ...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("m end ...");
        }
    }

    static class Chinese extends Person {
        @Override
        synchronized void m() {
            System.out.println("child m start ...");
            super.m();
            System.out.println("child m end ...");
        }
    }

}

四、synchronized遇到异常，线程会释放锁。

import java.util.concurrent.TimeUnit;

/**
 * 多线程环境synchronized遇到异常，线程会释放锁
 */
public class SynchronizedTest6 {

    int count = 0;

    synchronized void m() {
        System.out.println(Thread.currentThread().getName() + " start");
        while (true) {
            count++;
            System.out.println(Thread.currentThread().getName() + " count=" + count);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 5) {
                int i = 1/0; //此处会抛出异常，锁将被释放，想要锁不被释放，可以在这里进行catch，让循环继续.
                //java.lang.ArithmeticException: / by zero
                //解决办法： try-catch这个异常
            }
        }
    }

    public static void main(String[] args) {

        SynchronizedTest6 test = new SynchronizedTest6();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                test.m();
            }
        };

        new Thread(r, "线程1").start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(r, "线程2").start();

    }

}

五、synchronized优化

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * synchronized优化
 * synchronized代码块包住的代码越少越好
 */
public class SynchronizedTest7 {

    int count = 0;

    synchronized void add() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0; i<1000; i++) {
            count++;
        }
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


     void add1() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
         synchronized(this) {
             for(int i=0; i<1000; i++) {
                 count++;
             }
         }
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        SynchronizedTest7 test = new SynchronizedTest7();
        List<Thread> threads = new ArrayList<>(10);
        long start = System.currentTimeMillis();
        for(int i=0; i<10; i++) {
            threads.add(new Thread(() -> {
                test.add();
            }, "Thread" + i));
        }
        threads.forEach(t -> t.start());
        threads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.currentTimeMillis();
        System.out.println("add方法耗时：" + (end - start) + " count=" + test.count);

        //add1方法
        threads.clear();
        start = System.currentTimeMillis();
        for(int i=0; i<10; i++) {
            threads.add(new Thread(() -> {
                test.add1();
            }, "Thread" + i));
        }
        threads.forEach(t -> t.start());
        threads.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        end = System.currentTimeMillis();
        System.out.println("add1方法耗时：" + (end - start) + " count=" + test.count);

        ExecutorService service = Executors.newFixedThreadPool(10);
        start = System.currentTimeMillis();
        for(int i=0; i<10; i++) {
            service.submit(() -> {
                test.add();
            });
        }
        while (true) {
            if(!service.isTerminated()) break;
        }
        end = System.currentTimeMillis();
        System.out.println("ExecutorService add方法耗时：" + (end - start) + " count=" + test.count);
        service.shutdown();
//        if(service.isTerminated()) {
//            end = System.currentTimeMillis();
//            System.out.println("ExecutorService add方法耗时：" + (end - start) + " count=" + test.count);
//        }

        ExecutorService service1 = Executors.newFixedThreadPool(10);
        start = System.currentTimeMillis();
        for(int i=0; i<10; i++) {
            service1.submit(() -> {
                test.add1();
            });
        }
        while (true) {
            if(!service1.isTerminated()) break;
        }
        end = System.currentTimeMillis();
        System.out.println("ExecutorService add1方法耗时：" + (end - start) + " count=" + test.count);
        service1.shutdown();
//        if(service1.isTerminated()) {
//            end = System.currentTimeMillis();
//            System.out.println("ExecutorService add1方法耗时：" + (end - start) + " count=" + test.count);
//        }
    }

}

六、不要以字符串常量作为锁定对象

/**
 * 不要以字符串常量作为锁定对象
 * str1和str2是同一个都对象
 * 会发生诡异的死锁阻塞
 */
public class SynchronizedTest9 {

    String str1 = "Hello";
    String str2 = "Hello";

    void m1() {
        synchronized (str1) {

        }
    }

    void m2() {
        synchronized (str2) {

        }
    }

}

七、synchronized写法

public class SynchronizedTest2 {

    private static int count = 10;

    private synchronized void method() { //等同于synchronized(this)
        count--;
        System.out.println(Thread.currentThread().getName() + " count=" + count);
    }

    private static void method2() {
        synchronized (SynchronizedTest2.class) { //考虑一下这里写synchronized(this)是否可以？
            count--;
        }
    }

}