当前位置：网站首页>多线程之锁

多线程之锁

2022-07-31 17:25:00 【51CTO】

       
       /*
       
*作者：呆萌老师
       
*csdn认证讲师
       
*51cto高级讲师
       
*腾讯课堂认证讲师
       
*网易云课堂认证讲师
       
*华为开发者学堂认证讲师
       
*爱奇艺千人名师计划成员
       
*在这里给大家分享技术、知识和生活
       
*各种干货，记得关注哦！
       
*/
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

多线程之锁_java

线程锁分两种:内置锁(synchronized)和显式锁(ReentrantLock)

简单对比:

主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能，当许多线程都在争用同一个锁时，使用 ReentrantLock 的总体开支通常要比 synchronized 少得多。
synchronized会自动释放锁，而Lock一定要求程序员手工释放，为了防止忘记释放锁，一般在finally从句中释放。

Synchronized不能设置等待时间，所以如果等待的资源一直被占用，可能会出现死锁.

ReentrantLock会灵活一点，可以设置等待的时间，如果等待的时间到了，就会去做其它的任务.

       
       package 
       
       com.
       
       wowowo.
       
       lock;
       
       public 
       
       class 
       
       SellTicket 
       
       implements 
       
       Runnable {
       
       private 
       
       static 
       
       int 
       
       tickets
       
       =
       
       100;
       
       public 
       
       void 
       
       run()
       
    {
       
       while(
       
       true)
       
         {
       
       /*
       
       //隐士锁 内置锁 方式1 锁住代码块
       
       synchronized (this) { 
       
       if(tickets>0)
       
       { 
       
       System.out.println(Thread.currentThread().getName()+"售出第..."+tickets+"...张票");
       
       tickets--;
       
       try {
       
       Thread.sleep(10); //休眠 10毫秒
       
       } catch (InterruptedException e) {
       
       // TODO Auto-generated catch block
       
       e.printStackTrace();
       
       }
       
       }
       
       }*/
       
       //方式 2
       
       sellTicket();   
       
         }
       
    }
       
       //方式2 锁住方法(成员方法或静态方法)
       
       public 
       
       synchronized 
       
       void 
       
       sellTicket()
       
    {        
       
       if(
       
       tickets
       
       >
       
       0)
       
         {                 
       
       System.
       
       out.
       
       println(
       
       Thread.
       
       currentThread().
       
       getName()
       
       +
       
       "售出第..."
       
       +
       
       tickets
       
       +
       
       "...张票");
       
       tickets
       
       --;
       
       try {
       
       Thread.
       
       sleep(
       
       10); 
       
       //休眠 10毫秒
       
            } 
       
       catch (
       
       InterruptedException 
       
       e) {
       
       // TODO Auto-generated catch block
       
       e.
       
       printStackTrace();
       
            }
       
         }
       
    }
       
 }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.

       
       package com.wowowo.lock;
       
import java.util.concurrent.locks.Lock;
       
import java.util.concurrent.locks.ReentrantLock;
       
public class SellTicket2 implements Runnable {
       
  private static int tickets=100;
       
  //显示锁
       
  private Lock lock=new ReentrantLock();
       
  @Override
       
  public void run() {
       
    // TODO Auto-generated method stub
       
    while(true)
       
    {
       
      lock.lock(); //上锁
       
      //lock.tryLock(arg0, arg1)//设置等待的时间的
       
      if(tickets>0)
       
      {
       
        System.out.println(Thread.currentThread().getName()+"售出第.."+tickets+"..张票");
       
        tickets--;
       
        try {
       
          Thread.sleep(10);
       
        } catch (InterruptedException e) {
       
          // TODO Auto-generated catch block
       
          e.printStackTrace();
       
        }       
       
      }     
       
      //开锁
       
      lock.unlock(); 
       
    }
       
  }
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.

多线程之锁_锁_02

       
       package 
       
       com.
       
       wowowo.
       
       lock;
       
       import 
       
       java.
       
       util.
       
       concurrent.
       
       ExecutorService;
       
       import 
       
       java.
       
       util.
       
       concurrent.
       
       Executors;
       
       public 
       
       class 
       
       Test {
       
       /**
       
       * @param
       
       public static void main(String[] args) {
       
       // TODO Auto-generated method stub
       
       //创建线程池对象
       
       ExecutorService pool= Executors.newFixedThreadPool(3);
       
       //创建售票任务 对象
       
       SellTicket2 sellTicket=new SellTicket2();
       
       pool.submit(sellTicket);
       
       pool.submit(sellTicket);
       
       pool.submit(sellTicket);
       
       }
       
       }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.