继昨天学习了线程池之后，今天学习了多线程内的锁Lock。

定义方法：

ReentrantLock queueLock = new ReentrantLock(); //可重入锁

ReentrantReadWriteLock orderLock = new ReentrantReadWriteLock(); //可重入读写锁

每个锁都有个lock方法（上锁）和unlock方法（释放锁）

在写入锁的时候只能有一个线程，但是读取锁的时候可以线程一起共享锁里面的代码

今天还学习了信号量Semphore 自己定义最大可以同时运行多少线程

定义方法：

Semaphore placeSemaphore = new Semaphore(5);

使用acquire方法获得信号量 总信号量-1

使用release方法释放信号量 总信号量+1

附今日的代码：

  1 import java.util.concurrent.locks.ReentrantLock;
  2 import java.util.concurrent.locks.ReentrantReadWriteLock;
  3 
  4 public class LockExample {
  5 
  6     private static final ReentrantLock queueLock = new ReentrantLock(); //可重入锁
  7     private static final ReentrantReadWriteLock orderLock = new ReentrantReadWriteLock(); //可重入读写锁
  8     
  9     /**
 10      * 有家奶茶店，点单有时需要排队 
 11      * 假设想买奶茶的人如果看到需要排队，就决定不买
 12      * 又假设奶茶店有老板和多名员工，记单方式比较原始，只有一个订单本
 13      * 老板负责写新订单，员工不断地查看订单本得到信息来制作奶茶，在老板写新订单时员工不能看订单本
 14      * 多个员工可同时看订单本，在员工看时老板不能写新订单
 15      * @param args
 16      * @throws InterruptedException 
 17      */
 18     public static void main(String[] args) throws InterruptedException {
 19         //buyMilkTea();
 20         handleOrder(); //需手动关闭
 21     }
 22     
 23     public void tryToBuyMilkTea() throws InterruptedException {
 24         boolean flag = true;
 25         while(flag)
 26         {
 27             //判断queneLock现在是什么状态，如果是锁住的状态就返回false，如果是空闲状态则将它锁住返回true。
 28             if (queueLock.tryLock()) {
 29                 //queueLock.lock();
 30                 //随机睡眠一段时间
 31                 long thinkingTime = (long) (Math.random() * 500);
 32                 Thread.sleep(thinkingTime);
 33                 System.out.println(Thread.currentThread().getName() + "： 来一杯珍珠奶茶，不要珍珠");
 34                 flag = false;
 35                 //将锁释放
 36                 queueLock.unlock();
 37             } else {
 38                 //System.out.println(Thread.currentThread().getName() + "：" + queueLock.getQueueLength() + "人在排队");
 39                 System.out.println(Thread.currentThread().getName() + "： 再等等");
 40             }
 41             if(flag)
 42             {
 43                 Thread.sleep(1000);
 44             }
 45         }
 46         
 47     }
 48     
 49     public void addOrder() throws InterruptedException {
 50         //写入锁 锁住的情况下只能一个线程写
 51         orderLock.writeLock().lock();
 52         //睡眠一段时间
 53         long writingTime = (long) (Math.random() * 1000);
 54         Thread.sleep(writingTime);
 55         System.out.println("老板新加一笔订单");
 56         //释放锁
 57         orderLock.writeLock().unlock();
 58     }
 59     
 60     public void viewOrder() throws InterruptedException {
 61         //读取锁 锁住的情况下可以多个线程一起共享
 62         orderLock.readLock().lock();
 63         //睡眠一段时间
 64         long readingTime = (long) (Math.random() * 500);
 65         Thread.sleep(readingTime);
 66         System.out.println(Thread.currentThread().getName() + ": 查看订单本");
 67         //释放锁
 68         orderLock.readLock().unlock();            
 69 
 70     }
 71     
 72     //买奶茶方法
 73     public static void buyMilkTea() throws InterruptedException {
 74         LockExample lockExample = new LockExample();
 75         //定义线程数
 76         int STUDENTS_CNT = 10;
 77         //建立线程
 78         Thread[] students = new Thread[STUDENTS_CNT];
 79         for (int i = 0; i < STUDENTS_CNT; i++) {
 80             //给每个线程完成初始化
 81             students[i] = new Thread(new Runnable() {
 82 
 83                 @Override
 84                 public void run() {
 85                     try {
 86                         //随机睡眠一段时间
 87                         long walkingTime = (long) (Math.random() * 1000);
 88                         Thread.sleep(walkingTime);
 89                         //尝试现在是否能够买奶茶
 90                         lockExample.tryToBuyMilkTea();
 91                     } catch(InterruptedException e) {
 92                         System.out.println(e.getMessage());
 93                     }
 94                 }
 95                 
 96             }
 97             );
 98             //让所有线程开始工作
 99             students[i].start();
100         }
101         
102         for (int i = 0; i < STUDENTS_CNT; i++)
103             //等待所有线程结束
104             students[i].join();
105 
106     }
107     
108     
109     public static void handleOrder() throws InterruptedException {
110         LockExample lockExample = new LockExample();
111         
112         //创建了一个老板写的线程类并且完成了初始化。
113         Thread boss = new Thread(new Runnable() {
114 
115             @Override
116             public void run() {
117                 while (true) {
118                     try {
119                         //添加订单
120                         lockExample.addOrder();
121                         //随机睡眠一段时间
122                         long waitingTime = (long) (Math.random() * 1000);
123                         Thread.sleep(waitingTime);
124                     } catch (InterruptedException e) {
125                         System.out.println(e.getMessage());
126                     }
127                 }
128             }
129         });
130         //老板线程开始
131         boss.start();
132         //定义员工线程数
133         int workerCnt = 3;
134         //创建员工线程
135         Thread[] workers = new Thread[workerCnt];
136         for (int i = 0; i < workerCnt; i++)
137         {
138             //给每个员工线程初始化
139             workers[i] = new Thread(new Runnable() {
140 
141                 @Override
142                 public void run() {
143                     while (true) {
144                         try {
145                                 //查看订单
146                                 lockExample.viewOrder();
147                                 //睡眠一段时间
148                                 long workingTime = (long) (Math.random() * 5000);
149                                 Thread.sleep(workingTime);
150                             } catch (InterruptedException e) {
151                                 System.out.println(e.getMessage());
152                             }
153                         }
154                 }
155                 
156             });
157             //员工线程开始工作
158             workers[i].start();
159         }
160         
161     }
162 }

 1 import java.util.concurrent.Semaphore;
 2 
 3 public class SemaphoreExample {
 4     //定义了5个车位
 5     private final Semaphore placeSemaphore = new Semaphore(5);
 6     
 7     public boolean parking() throws InterruptedException {
 8         //如果此时Semaphore信号量不为0就会获取一个信号量返回true并且信号量－1，如果信号量为0的话则返回false
 9         if (placeSemaphore.tryAcquire()) {
10             System.out.println(Thread.currentThread().getName() + ": 停车成功");
11             return true;
12         } else {
13             System.out.println(Thread.currentThread().getName() + ": 没有空位");
14             return false;
15         }
16 
17     }
18     
19     public void leaving() throws InterruptedException {
20         //释放掉一个信号量，信号量+1
21         placeSemaphore.release();
22         System.out.println(Thread.currentThread().getName() + ": 开走");
23     }
24     
25     /**
26      * 现有一地下车库，共有车位5个，由10辆车需要停放，每次停放时，去申请信号量
27      * @param args
28      * @throws InterruptedException 
29      */
30     public static void main(String[] args) throws InterruptedException {
31         //定义总共要停车的数量
32         int tryToParkCnt = 10;
33         
34         SemaphoreExample semaphoreExample = new SemaphoreExample();
35         //创建要停车的数量的线程
36         Thread[] parkers = new Thread[tryToParkCnt];
37         
38         for (int i = 0; i < tryToParkCnt; i++) {
39             //将每个线程进行初始化
40             parkers[i] = new Thread(new Runnable() {
41 //这是视频里面的源代码，我在运行之后发现结果和我想象中的有点不同，因为有的车没有停到车位，不是等待之后再停车，而是直接没有停车了。
42 //原因是不管if里面返回true或是false都只会执行一次，如果是false的话就只输出了一个没有空位，然后线程就结束了。
43 //所以我在if判断的外面加了一个while死循环，当if为true，车成功的停车然后离开车位之后break退出循环。
44 //                @Override
45 //                public void run() {
46 //                    try {
47 //                        long randomTime = (long) (Math.random() * 1000);
48 //                        Thread.sleep(randomTime);
49 //                        if (semaphoreExample.parking()) {
50 //                            long parkingTime = (long) (Math.random() * 1200);
51 //                            Thread.sleep(parkingTime);
52 //                            semaphoreExample.leaving();
53 //                        }
54 //                    } catch (InterruptedException e) {
55 //                        e.printStackTrace();
56 //                    }
57 //                }
58                 @Override
59                 public void run() {
60                     try {
61                         exit:
62                         while(true)
63                         {    
64                             //睡眠一段时间
65                             long randomTime = (long) (Math.random() * 1000);
66                             Thread.sleep(randomTime);
67                             //尝试进行停车，如果停车成功会返回true
68                             if (semaphoreExample.parking()) {
69                                 //睡眠一段时间，然后调用离开方法
70                                 long parkingTime = (long) (Math.random() * 1200);
71                                 Thread.sleep(parkingTime);
72                                 semaphoreExample.leaving();
73                                 break exit;
74                             }
75                         }
76                     } catch (InterruptedException e) {
77                         e.printStackTrace();
78                     }
79                 }
80             });
81             //让每个线程开始工作
82             parkers[i].start();
83         }
84 
85         for (int i = 0; i < tryToParkCnt; i++) {
86             //等待每个线程结束
87             parkers[i].join();
88         }    
89     }
90 }