java内置锁的简单认识

我不是女神ヾ 2023-10-06 11:32 28阅读 0赞

多线程开发离不开锁机制，现在的Java语言中，提供了2种锁，一种是**语言特性提供的内置锁**，还有一种是 **java.util.concurrent.locks 包中的锁**，这篇文章简单整理一下内置锁的知识点。

## 1、内置锁在Java语言中的表现： ##

多线程的锁，其实本质上就是给一块内存空间的访问添加访问权限，因为Java中是没有办法直接对某一块内存进行操作的，又因为Java是面向对象的语言，一切皆对象，所以具体的表现就是某一个对象承担锁的功能，每一个对象都可以是一个锁。

**内置锁**，使用方式就是使用 synchronized 关键字，synchronized 方法或者 synchronized 代码块。

## 2、每一种 synchronized 写法的锁是哪个对象： ##

### 2.1、指定当前对象加锁： ###

private synchronized void function() {
            //TODO execute something
      }

### 2.2、指定当前类的Class对象加锁： ###

private static synchronized void function() {
        //TODO execute something
    }

注意此处的 static 关键字。

### 2.3、指定任意对象加锁： ###

private void function() {
        synchronized (object) {
            //TODO execute something
        }
    }

此时，这段同步代码块的锁加在object对象上面。该对象可以是当前对象（object == this），也可以是当前类的Class对象（object == MyClass.class）。

## 3、验证 ##

public class SynchronizedTest {
        private Object lock = new Object();
    
        public void synchronizedBlockOnObject(long executeTime) {
            // lock对象锁
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnObject");
                doSomething(executeTime);
                System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnObject");
            }
        }
    
        public void synchronizedBlockOnThis(long executeTime) {
            // 当前实例对象锁
            synchronized (this) {
                System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnThis");
                doSomething(executeTime);
                System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnThis");
            }
        }
    
        public void synchronizedBlockOnClass(long executeTime) {
            // 类锁
            synchronized (SynchronizedTest.class) {
                System.out.println(Thread.currentThread().getName() + " -> start synchronizedBlockOnClass");
                doSomething(executeTime);
                System.out.println(Thread.currentThread().getName() + " -> end synchronizedBlockOnClass");
            }
        }
    
        // 非静态方法，当前实例对象锁
        public synchronized void synchronizedMethodOnThis(long executeTime) {
            System.out.println(Thread.currentThread().getName() + " -> start synchronizedMethodOnThis");
            doSomething(executeTime);
            System.out.println(Thread.currentThread().getName() + " -> end synchronizedMethodOnThis");
        }
    
        // 静态方法，类锁（SynchronizedTest.class）
        public static synchronized void synchronizedMethodOnClass(long executeTime) {
            System.out.println(Thread.currentThread().getName() + " -> start synchronizedMethodOnClass");
            doSomething(executeTime);
            System.out.println(Thread.currentThread().getName() + " -> end synchronizedMethodOnClass");
        }
    
        private static void doSomething(long executeTime) {
            try {
                Thread.sleep(executeTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
       
    }

### 3.1、static synchronized 方法 和 synchronized (MyClass.class) \{\} 同步代码块的锁都加在 MyClass.class 对象上面： ###

public static void main(String[] args) {
         SynchronizedTest synchronizedTest = new SynchronizedTest();
            
         new Thread(new Runnable() {
             @Override
             public void run() {
                  SynchronizedTest.synchronizedMethodOnClass(3000);
             }
         }, "Thread static synchronized method").start();
           
         new Thread(new Runnable() {
             @Override
             public void run() {
                 synchronizedTest.synchronizedBlockOnClass(2000);
             }
        }, "Thread synchronized block on Class").start();
    }

> 运行结果：
> 
> Thread static synchronized method -> start synchronizedMethodOnClass  
> Thread static synchronized method -> end synchronizedMethodOnClass  
> Thread synchronized block on Class -> start synchronizedBlockOnClass  
> Thread synchronized block on Class -> end synchronizedBlockOnClass
> 
> 说明当线程 Thread static synchronized method 进入方法 synchronizedMethodOnClass 的时候，线程Thread synchronized block on Class 是不能进入synchronizedBlockOnClass 代码块的。

### 3.2、非 static 的 synchronized 方法和 synchronized (this) \{\} 同步代码块的锁都加在当前对象上面： ###

>     运行结果如下：
>     
>     Thread non-static synchronized method -> start synchronizedMethodOnThis
>     Thread non-static synchronized method -> end synchronizedMethodOnThis
>     Thread synchronized block on this -> start synchronizedBlockOnThis
>     Thread synchronized block on this -> end synchronizedBlockOnThis
>     
>     说明当线程 Thread non-static synchronized method 进入方法 synchronizedMethodOnThis 的时候，线程Thread synchronized block on this 是不能进入synchronizedBlockOnThis 代码块的。

### 3.3、三个方法中：锁分别加在 MyClass.class 、 this 、 任意对象，起不到任何同步作用： ###

public static void main(String[] args) {
            SynchronizedTest synchronizedTest = new SynchronizedTest();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronizedTest.synchronizedMethodOnThis(3000);
                }
            }, "Thread non-static synchronized method").start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    SynchronizedTest.synchronizedMethodOnClass(2000);
                }
            }, "Thread static sybchronized method").start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronizedTest.synchronizedBlockOnObject(4000);
                }
            }, "Thread sybchronized block on other Object").start();
        }

> 运行结果如下：
> 
>     Thread non-static synchronized method -> start synchronizedMethodOnThis
>     Thread static sybchronized method -> start synchronizedMethodOnClass
>     Thread sybchronized block on other Object -> start synchronizedBlockOnObject
>     Thread static sybchronized method -> end synchronizedMethodOnClass
>     Thread non-static synchronized method -> end synchronizedMethodOnThis
>     Thread sybchronized block on other Object -> end synchronizedBlockOnObject
>     
>     说明当锁没有加在同一个对象上的时候，起不到线程间的同步作用。

## 4、Object中对内置锁进行操作的一些方法： ##

### 4.1、wait()： ###

wait()系列方法的作用是：使当前已经获得该对象锁的线程进入等待状态，并且立即释放该对象的锁，等待的到相应的notify重新获得锁后才继续执行。

### 4.2、notify()： ###

notify()系列方法的作用是：不会立刻释放锁，而是等到notify所在synchronized代码块全部都执行完以后才会释放锁。

notifyAll() 会通知等待队列中的所有线程。

### 4.3、基于wait() 、notify()机制，我们可以实现一个简易的生产者-消费者模型。 ###

大体思路如下，一个生产者线程负责向一个仓库中存放（put）物品，一个消费者线程负责从仓库中取出（get）物品。

public class Warehouse {
    
        private Queue<Integer> queue;
        private int capacity;
    
        public Warehouse(int capacity) {
            this.capacity = capacity;
            queue = new LinkedList();
        }
    
        public synchronized void put(int num) {
            if (queue.size() >= capacity) {
                try {
                    System.out.println(Thread.currentThread().getName() + " , put full wait");
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.add(num);
            System.out.println(Thread.currentThread().getName() + " , put : " + num + "  , queue -> " + queue);
            notifyAll();
        }
    
        public synchronized int get() {
            if (queue.isEmpty()) {
                try {
                    System.out.println(Thread.currentThread().getName() + " , get empty wait");
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            int num = queue.poll();
            System.out.println(Thread.currentThread().getName() + " , get : " + num + "  , queue -> " + queue);
            notifyAll();
            return num;
        }
    
    
        public static void main(String[] args) {
            Warehouse warehouse = new Warehouse(4);
            Random random = new Random();
    
            // 简易的生产者、消费者
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        warehouse.put(random.nextInt(10));
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "生产者-01").start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        warehouse.get();
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "消费者-01").start();
        }
    }

运行结果如下：

> 生产者-01 , put : 3 , queue -> \[3\]  
> 消费者-01 , get : 3 , queue -> \[\]  
> 生产者-01 , put : 5 , queue -> \[5\]  
> 消费者-01 , get : 5 , queue -> \[\]  
> 生产者-01 , put : 8 , queue -> \[8\]  
> 生产者-01 , put : 2 , queue -> \[8, 2\]  
> 消费者-01 , get : 8 , queue -> \[2\]  
> 生产者-01 , put : 6 , queue -> \[2, 6\]  
> 生产者-01 , put : 0 , queue -> \[2, 6, 0\]  
> 消费者-01 , get : 2 , queue -> \[6, 0\]  
> 生产者-01 , put : 6 , queue -> \[6, 0, 6\]  
> 生产者-01 , put : 6 , queue -> \[6, 0, 6, 6\]  
> 消费者-01 , get : 6 , queue -> \[0, 6, 6\]  
> 生产者-01 , put : 4 , queue -> \[0, 6, 6, 4\]  
> 生产者-01 , put full wait  
> 消费者-01 , get : 0 , queue -> \[6, 6, 4\]  
> 生产者-01 , put : 8 , queue -> \[6, 6, 4, 8\]  
> 生产者-01 , put full wait  
> 消费者-01 , get : 6 , queue -> \[6, 4, 8\]  
> 生产者-01 , put : 3 , queue -> \[6, 4, 8, 3\]  
> 生产者-01 , put full wait  
> 消费者-01 , get : 6 , queue -> \[4, 8, 3\]  
> 生产者-01 , put : 5 , queue -> \[4, 8, 3, 5\]  
> 生产者-01 , put full wait

## 5、缺点： ##

内置锁在进入同步块时，采取的是无限等待的策略，一旦开始等待，就既不能中断也不能取消，容易产生饥饿与死锁的问题。

在线程调用notify方法时，会**随机选择相应对象的等待队列的一个线程将其唤醒**，而不是按照FIFO（先入先出策略）的方式，如果有强烈的公平性要求，就无法满足。

Synchronized在JDK1.5及之前性能（主要指吞吐率）比较差，扩展性也不如ReentrantLock。但是JDK1.6以后，修改了管理内置锁的算法，使得Synchronized和标准的ReentrantLock性能差别不大。