Synchronized的特性

一、可重入特性 1.1 什么是可重入

一个线程可以多次执行synchronized，重复获取同一把锁。

 1.2. 可重入原理

synchronized的锁对象中有一个计数器（recursions变量）会记录线程获得几次锁.

1.3 可重入的好处

1. 可以避免死锁

2. 可以让我们更好的来封装代码

总结：

synchronized是可重入锁，内部锁对象中会有一个计数器记录线程获取几次锁啦，在执行完同步代码块时，计数器的数量会-1，直到计数器的数量为0，就释放这个锁。

二、不可中断特性 2.1 什么是不可中断

一个线程获得锁后，另一个线程想要获得锁，必须处于阻塞或等待状态，如果第一个线程不释放锁，第二个线程会一直阻塞或等待，不可被中断。

2.2 Synchronized不可中断演示

synchronized是不可中断，处于阻塞状态的线程会一直等待锁。 

/**
 * 目标：演示synchronized不可中断
 * 1. 定义一个Runnable
 * 2. 在Runnable定义同步代码块
 * 3. 先开启一个线程来执行同步代码块，保证不退出同步代码块
 * 4. 后开启一个线程来执行同步代码块(阻塞状态)
 * 5. 停止第二个线程
 */
public class Demo02_UnInterruptible {

    private static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        // 1. 定义一个Runnable
        Runnable run = () -> {
            // 2. 在Runnable定义同步代码块
            synchronized (obj) {
                String name = Thread.currentThread().getName();
                System.out.println(name + "进入同步代码块");
                // 保证不退出同步代码块
                try {
                    Thread.sleep(888888);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        // 3. 先开启一个线程来执行同步代码块
        Thread t1 = new Thread(run);
        t1.start();
        Thread.sleep(1000);
        // 4. 后开启一个线程来执行同步代码块(阻塞状态)
        Thread t2 = new Thread(run);
        t2.start();

        // 5.停止第二个线程
        System.out.println("停止线程前");
        t2.interrupt();
        System.out.println("停止线程后");

        System.out.println(t1.getState());

        System.out.println(t2.getState());
    }
}

 2.3 ReentrantLock不可中断演示

/**
 * 目标：演示Lock不可中断和可中断
 */
public class Demo03_Interruptible {

    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        test01();
    }

    // 演示Lock不可中断
    public static void test01() throws InterruptedException {
        Runnable run = () -> {
            String name = Thread.currentThread().getName();
            try {
                lock.lock();
                System.out.println(name + "获得锁，进入锁执行");
                Thread.sleep(88888);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
                System.out.println(name + "释放锁");
            }
        };

        Thread t1 = new Thread(run);
        t1.start();

        Thread.sleep(1000);

        Thread t2 = new Thread(run);
        t2.start();

        Thread.sleep(1000);
        System.out.println(t1.getState());
        System.out.println(t2.getState());

    }
}

 2.4 ReentrantLock可中断演示

/**
 * 目标：演示Lock不可中断和可中断
 */
public class Demo04_Interruptible {

    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        test01();
    }

    // 演示Lock不可中断
    public static void test01() throws InterruptedException {

        Runnable run = () -> {
            String name = Thread.currentThread().getName();
            boolean b = false;
            try {
                lock.tryLock(3, TimeUnit.SECONDS);
                if (b) {
                    System.out.println(name + "获得锁，进入锁执行");
                    Thread.sleep(88888);
                } else {
                    System.out.println(name + "在指定时间没有得到锁做其他操作");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (b) {
                    lock.unlock();
                    System.out.println(name + "释放锁");
                }
            }
        };

        Thread t1 = new Thread(run);
        t1.start();

        Thread.sleep(1000);

        Thread t2 = new Thread(run);
        t2.start();

    }
}

总结：

不可中断是指，当一个线程获得锁后，另一个线程一直处于阻塞或等待状态，前一个线程不释放锁，后一个线程会一直阻塞或等待，不可被中断。

synchronized属于不可被中断

Lock的lock方法是不可中断的

Lock的tryLock方法是可中断的

参考博客、视频教程