day27- 同步方法

同步方法

死锁的概念

1. 互斥条件：一个资源每次只能被一个进程使用

2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放

3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺

4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

synchronized 方法

使用synchronized方法和synchronized块

每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行会独占该锁，知道该方法返回才释放该锁

lock方法

定义lock锁，在使用同步资源前加锁，在使用结束后释放该锁

//定义lock锁
 private final ReentrantLock lock = new ReentrantLock();

 

加锁

 lock.lock();//加锁

 

解锁

 lock.unlock();//解锁

 

一般配合try catch使用，解锁放在finally中

 //测试lock锁
 public class TestLock {
     public static void main(String[] args) {
         TestLock2 testLock2 = new TestLock2();
         new Thread(testLock2).start();
         new Thread(testLock2).start();
         new Thread(testLock2).start();
     }
 }
 ​
 class TestLock2 implements Runnable{
     int tickstnum =10;
     //定义lock锁
     private final ReentrantLock lock = new ReentrantLock();
     @Override
     public void run() {
         while (true){
 ​
             try {
                 lock.lock();//加锁
 ​
                 if (tickstnum > 0) {
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println(tickstnum--);
                 } else {
                     break;
                 }
             }finally {
                 lock.unlock();//解锁
             }
         }
 ​
     }
 }

 

synchronized与lock

1. lock是显式锁，手动开启和关闭，synchronized是隐式锁，出了作用域自动释放

2. lock只有代码锁，synchronized有代码块和方法锁

3. lock性能更好

利用缓冲区解决，管程法

定义缓冲区，定义拿取函数

使用synchronized定义

//缓冲区
 class SynContainer{
     //容器大小
     Chicken[] chickens = new Chicken[10];
     //容器计数器
     int count = 0;
     //生产者放入产品
     public synchronized void push(Chicken chicken) throws InterruptedException {
         //如果容器满了 需要等待消费者消费
         if(count == chickens.length){
             //通知消费者等待
             this.wait();
         }
         //如果没满 可以丢入产品
         chickens[count] = chicken;
         count++;
         //通知消费者消费
         this.notifyAll();
     }
 ​
 ​
     //消费者取走产品
     public synchronized Chicken pop() throws InterruptedException {
         //判断能否消费
         if (count == 0){
             //等待生产者生产
             this.wait();
         }
         //如果可以生产
         count--;
         Chicken chicken = chickens[count];
 ​
 ​
         //吃完了 通知生产者生产
         this.notifyAll();
         return chicken;
     }
 }

 

定义生产者消费者进程 通过缓冲区调用该进程

//生产者消费者模型-> 利用缓冲区解决：管程法
 public class TestPC {
     public static void main(String[] args) {
         SynContainer container = new SynContainer();
         new Producer(container).start();
         new Consumer(container).start();
     }
 }
 ​
 //生产者
 class Producer extends Thread{
     SynContainer container;
     public Producer(SynContainer container){
         this.container = container;
     }
     //生产
     @Override
     public void run() {
         for (int i = 0; i < 100; i++) {
             System.out.println("生产了"+i+"只鸡");
             try {
                 container.push(new Chicken(i));
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 ​
 //消费者
 class Consumer extends Thread{
     SynContainer container;
     public Consumer(SynContainer container){
         this.container = container;
     }
     //消费
     @Override
     public void run() {
         for (int i = 0; i < 100; i++) {
             try {
                 System.out.println("消费了-->"+container.pop().id+"只鸡");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }
 ​
 //产品
 class Chicken{
     int id;
 ​
     public Chicken(int id) {
         this.id = id;
     }
 }

 

 

表演者与观众同步进程

 public class TestPc2 {
     public static void main(String[] args) {
         TV tv = new TV();
         new Player(tv).start();
         new Watcher(tv).start();
     }
 }
 ​
 //生产者->演员
 class Player extends Thread{
     TV tv;
     public Player(TV tv){
         this.tv = tv;
     }
     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {
             if(i%2==0){
                 tv.play("快乐大本营");
             }else{
                 tv.play("抖音");
             }
         }
     }
 }
 //消费者->观众
 class Watcher extends  Thread{
     TV tv;
     public Watcher(TV tv){
         this.tv = tv;
     }
     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {
             tv.watch();
         }
     }
 }
 //产品->节目
 class TV{
     String name;
     boolean flag = true;
 ​
     //表演
     public synchronized void play(String name){
         if (!flag){
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         System.out.println("表演了 "+name);
         this.notifyAll();
         this.name = name;
         this.flag = !this.flag;
 ​
     }
     //观看
     public synchronized void watch(){
         if(flag){
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         System.out.println("观看了 "+name);
         this.notifyAll();
         this.flag = !this.flag;
 ​
     }
 }

 

线程池

 //测试线程池
 public class TestPool {
     public static void main(String[] args) {
         //1.创建线程池
         //newFixedThreadPool参数为：线程池大小
         ExecutorService service = Executors.newFixedThreadPool(10);
 ​
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
         //2.关闭连接
         service.shutdown();
     }
 }
 ​
 ​
 class MyThread implements Runnable{
     @Override
     public void run() {
 ​
             System.out.println(Thread.currentThread().getName());
 ​
     }
 }