题目：三个售票员 卖出 30张票 || 多线程编程的企业级套路+模板||synchronized与Lock的区别

 

package com.dym.juc;

//资源类
class Ticket
{
  private int number =30;
  public synchronized void saleTicket()
  {
      if(number>0)
      {
          System.out.println(Thread.currentThread().getName()+"\t卖出第："+(number--)+"\t还剩下："+number);
      }
  }

}


//题目：三个售票员  卖出   30张票
// 多线程编程的企业级套路+模板
// 1 在高内聚 低耦合的前提下， 线程  操作（对外暴露的调用方法）   资源类
public class SaleTicket {
    public static void main(String[] args) {  // main 一切程序的入口
        Ticket ticket=new Ticket();
        //Thread(Runnable target,String name)  Allocates a new Thread object
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=40 ; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=40 ; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=40 ; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();
    }
}

---

---

synchronized  是一个重量级的锁

---

---

Lock 是什么？？

 

使用 Lock，而不使用 synchronized  的原因是因为：缩小锁的粒度范围

package com.dym.juc;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//资源类
class Ticket
{
  private int number =30;
  private Lock lock=new ReentrantLock();
  public  void saleTicket()
  {
      lock.lock();
      try
      {
          if(number>0)
          {
              System.out.println(Thread.currentThread().getName()+"\t卖出第："+(number--)+"\t还剩下："+number);
          }
      }finally
      {
        lock.unlock();
      }
  }
}


//题目：三个售票员  卖出   30张票
// 多线程编程的企业级套路+模板
// 1 在高内聚 低耦合的前提下， 线程  操作（对外暴露的调用方法）   资源类
public class SaleTicket {
    public static void main(String[] args) {  // main 一切程序的入口
        Ticket ticket=new Ticket();
        //Thread(Runnable target,String name)  Allocates a new Thread object
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=40 ; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=40 ; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <=40 ; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();
    }
}

---

---

synchronized与Lock的区别 

1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
5.synchronized的锁不可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。