Synchronized关键字的使用

深藏阁楼爱情的钟 2022-06-14 00:46 188阅读 0赞

## Synchronized关键字的使用 ##

#### Synchronized同步的三种方式 ####

*  对象锁同步代码块
    
        private final static Object lock = new Object();
        
        synchronized (lock) { // 对象锁
            // 需要同步的代码 
        }
 *  类锁同步代码块
    
        synchronized (Object.class) {
             // 类锁
            // 需要同步的代码 
        }
 *  同步方法
    
        public synchronized void get(){
            // 方法代码
        }
        
        
        public static synchronized void get(){
            // 方法代码
        }

#### 类锁与对象锁 ####

*  对象锁：Java的所有对象都含有一个互斥锁，这个锁由JVM自动获取和释放。线程进入synchronized方法的时候获取该对象锁，如果其他线程获取该对象，那么当前线程会等待锁的获取。当synchronized方法正常执行返回或抛出异常终止，JVM会自动释放对象锁。
 *  类锁： 对象锁是用来控制实例方法之间的同步，类锁是用来控制静态方法（静态同步代码块）之间的同步。其实类锁是一个概念上的东西，不是真实存在的，只是用来帮助理解静态方法与实例方法之间的区别的概念。

#### Synchronized关键字的使用，保障线程同步的案例 ####

public class Test { 
        public static void main(String[] args) {
            Task task = new Task();
            new Thread(task, "thread1").start();
            new Thread(task, "thread2").start();
            new Thread(task, "thread3").start();
            new Thread(task, "thread4").start();
        }
    
    
        public static class Task implements Runnable { 
            private int count = 10;
    
            @Override
            public void run() {
                while (true) {
                    synchronized (Task.class) {
                        try {
                            Thread.sleep(0);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if (count > 0) {
                            System.out.println(Thread.currentThread().getName() + ": count值" + count--);
                        }
                        if (count <= 0) {
                            break;
                        }
                    }
                }
            }
        }
    }

打印出来的结果，count值的顺序是10-1:

thread1: count值10
    thread1: count值9
    thread4: count值8
    thread2: count值7
    thread3: count值6
    thread2: count值5
    thread4: count值4
    thread1: count值3
    thread4: count值2
    thread2: count值1

#### 死锁 ####

多个线程同时阻塞，他们中的一个或者全部都在等待某个资源释放。由于线程被无限期的阻塞，因此程序不可能正常终止。

Java死锁产生的四个必要条件：

*  互斥使用。当资源被一个线程占用时，别的线程不能使用。
 *  不可抢占。资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
 *  请求和保持，当资源请求者在请求其他的资源的同时保持对原有资源的占用。
 *  循环等待。如：存在一个等待队列，P1占有P2的资源，P2占有P3的资源，P3占有P1的资源，这样就形成了一个等待环路。彼此都不能释放。

当上述4个条件都成立的时候，便形成死锁。

#### 死锁案例 ####

public class Test { 
    
        public static Object object1 = new Object();
        public static Object object2 = new Object();
    
        public static void main(String[] args) {
            Task1 task1 = new Task1();
            Task2 task2 = new Task2();
            new Thread(task1, "thread1").start();
            new Thread(task2, "thread2").start();
        }
    
        public static class Task1 implements Runnable { 
    
            @Override
            public void run() {
                synchronized (object1) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "： 睡10毫秒");
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    synchronized (object2) {
                        System.out.println(Thread.currentThread().getName() + "： 执行了 ");
                    }
                }
            }
        }
    
        public static class Task2 implements Runnable { 
    
            @Override
            public void run() {
                synchronized (object2) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "： 睡10毫秒");
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    synchronized (object1) {
                        System.out.println(Thread.currentThread().getName() + "： 执行了 ");
                    }
                }
            }
        }
    }

打印结果是：

thread1： 睡10毫秒
    thread2： 睡10毫秒

程序还是一直运行的，没有打印出后面的语句，表示2个线程相互持有对方需要的锁，并且相互不释放，导致了死锁。