2021-06-18

学习java第二十三天

线程同步
为什么要线程同步
因为当我们有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作时，就会导致变量值或对象的状态出现混乱，从而导致程序异常。举个例子，如果一个银行账户同时被两个线程操作，一个取100块，一个存钱100块。假设账户原本有0块，如果取钱线程和存钱线程同时发生，会出现什么结果呢？取钱不成功，账户余额是100.取钱成功了，账户余额是0.那到底是哪个呢？很难说清楚。因此多线程同步就是要解决这个问题。
同步方法
同步方法: 就是把synchronined关键字加到方法上

格式
修饰符sychonred 返四值类型 方法名(方法参数){ }
同步方法的锁对象是什么呢?

this
同步静态方法 :就是synchronized以关键字加到静态方法上

格式:
修饰符static synchronized返四值类型 方法名(方法参数)｛｝
同步静态方法的锁是什么呢？

类名. class

package demo01;
/*
 * 解决线程安全的第二种方法：使用同步方法
 * 使用步骤：
 *  1.把访问了共享数据的代码块抽取出来，放到一个方法中
 *  2.在方法上添加synchronized修饰符
 */
public class RunnableImpl implements Runnable{
private int ticket=100;
//Object obj=new Object
@Override
public void run() {
	while(true) {
		payTicket();
			
}
}

private synchronized void payTicket() {
	if(ticket>0) {
		try {
			Thread.sleep(10);
		}catch(InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"票");
		ticket--;
	
}
}
}

package demo02;

public class demo01Ticket {
	public static void main(String[] args) {
		Runnablempl run= new Runnablempl();
		Thread t0= new Thread(run);
		Thread t1= new Thread(run);
		Thread t2= new Thread(run);
		
		t0.start();
		t1.start();
		t2.start();
	}

}

Lock锁
Lock接口提供了与synchronized相似的同步功能，和synchronized（隐式的获取和释放锁，主要体现在线程进入同步代码块之前需要获取锁退出同步代码块需要释放锁）不同的是，Lock在使用的时候是显示的获取和释放锁。虽然Lock接口缺少了synchronized隐式获取释放锁的便捷性，但是对于锁的操作具有更强的可操作性、可控制性以及提供可中断操作和超时获取锁等机制。

package demo02;

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

/*
 * 
 * 解决线程安全的第二种方法：使用同步方法
 * 	使用步骤：
 * 		1、把访问了共享数据的代码块抽取出来，放到一个方法中
 * 		2、在方法上添加synchronized修饰符
 * 
 */
public class Runnablempl implements Runnable{
	private int ticket=100;
	//1.在成员位置创建一个Reentrantlock对象
	Lock l=new ReentrantLock();
	@Override
	public void run() {
		
		while(true) {
			//2.在可能会出现线程安全的地方，调用lock接口中的lock方法，获取锁
			
			l.lock();
			if(ticket>0) {
				
				try {
					Thread.sleep(10);
					System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
					ticket--;
				}catch (InterruptedException e) {
					e.printStackTrace();
				
				}finally {
					l.unlock();
				}
			//3.在可能出现线程安全问题的代码调用过后，使用unlock释放锁
		}
	}
	}
}

package demo02;

import demo01.RunnableImpl;

public class Ticket {
public static void main(String[] args) {
	RunnableImpl run=new RunnableImpl();
	Thread t0=new Thread(run);
	Thread t1=new Thread(run);
	Thread t2=new Thread(run);
	t0.start();
	t1.start();
	t2.start();
}
}

生产者与消费者的问题
创建一个顾客线程：告知老板包子的种类，用wait（）方法等待，放弃CPU执行。
创建一个老板线程：花5秒做包子，做好后用notif 通知顾客拿包子

package com.hg.day23.demo03;

public class Demo03WatiAndNotify {
    public static void main(String[] args) {
        Object obj = new Object();
        //创建第一个消费者
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    synchronized (obj) {
                        System.out.println("消费者1：告知老板要的包子的种类");
                        try {
                            //等待有人来唤醒我
                            obj.wait();
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                        System.out.println("消费者1：包子已经好了，开吃");
                        System.out.println("===========================");
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                while (true) {
                    synchronized (obj) {
                        System.out.println("消费者2：告知老板要的包子的种类");
                        try {
                            //等待有人来唤醒我
                            obj.wait();
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                        System.out.println("消费者2：包子已经好了，开吃");
                        System.out.println("===========================");
                    }
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                //一直要包子
                while (true) {
                    //花五秒做一个包子
                        try {
                           Thread.sleep(2000);
                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                       synchronized(obj) {
                           System.out.println("生产者：老板花2秒做好了2个包子，告诉客户吃包子");
                           //obj.notify();
                           obj.notifyAll();
                       }
                    }
                }
        }.start();
    }
}