Java知识点复习：Day23

知识点

---

Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外 等着。

线程状态

匿名内部类方式实现线程的创建

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

---

课堂实践

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();
		}
	}
	public synchronized void payTicket() {
		if(ticket>0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				
			   e.printStackTrace();
			}
			
				System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
				ticket--;
		}
	}
}

	

package Demo01;



public class Demo01Ticket {
	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();
	}
}

package Demo02;
/*
 * 
 * 解决线程安全的第二种方法：使用Lock锁
 * 使用步骤：
 *        1、void lock()   获取锁
 *        2、void unlock() 释放锁
 * 
 * 
 * 
 * 
 */

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

public class RunnableImpl implements Runnable {
	private int ticket=100;
	// 在成员位置创建一个Reentrantlock对象
	Lock l=new ReentrantLock();
	@Override
	public void run() {
		while(true) {
			// 在可能会出现线程安全的地方，调用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 {
						// 在可能出现线程安全问题的代码调用之后，使用unlock 释放锁
						l.unlock();
					}
			}
		}
	}
	
	
}

package Demo02;



public class Demo01Ticket {
	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();
	}
}

package Demo03;
/*
 * 
 * 等待唤醒案例：
 *    创建一个顾客线程：告知老板要的包子的种类，用wait()  方法等待，  放弃cpu执行
 *    创建一个老板线程：  花5秒做一个包子，
 * 
 * 
 * 
 * 
 * 
 */
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) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						System.out.println("消费者2：包子已经做好了，开吃");
						System.out.println("====================");
					}
				}
			}
		}.start();
		
		
		new Thread() {
			@Override
			public void run() {
				// 一直做包子
				while(true) {
		
					// 花2秒做一个包子
						
						try {
							// 等待有人来唤醒我
							Thread.sleep(2000);
						} catch (InterruptedException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						
						synchronized (obj) {
						System.out.println("生产者：老板花2秒做好了2个包子，告知顾客吃包子");
						//obj.notify();
						obj.notifyAll();
					}
				}
			}
		}.start();
	}
}

---

2020080605036