并发编程3-线程调度

短命女 2022-08-06 12:04 113阅读 0赞

## 状态图： ##

![Center][]

方法说明：

run 线程运行的主体

yield() 放弃当前的时间片进入可运行状态，可以被再次选中

start() 线程进入可运行阶段

sleep(), 阻塞一定的时间，会持有锁

t2.join() 等待t2线程运行结束，会持有锁，有可能会死锁

wait()   锁对象的方法，持有锁对象的线程释放锁，进入阻塞队列等待notify

notify() 锁对象的方法，唤醒一个该锁对象阻塞队列中的线程

notifyAll()  锁对象的方法，唤醒所有该锁对象阻塞队列中的线程

## wait , notify, notifyAll ##

class SynClass{
    	public void execute(){
    		System.out.println(Thread.currentThread().getName());
    	}
    }

final SynClass sc = new SynClass();
    		Thread[] ts = new Thread[10];
    		for (int i = 0; i < 10; i++) {
    			ts[i] = new Thread("thread" + i){
    				public void run() {
    					synchronized (sc) {
    						try {
    							sc.wait();
    							sc.execute();
    						} catch (InterruptedException e) {
    							e.printStackTrace();
    						}
    					}
    				};
    			};
    		}
    		
    		for (Thread t : ts) {
    			t.start();
    		}
    		
    		TimeUnit.SECONDS.sleep(1);
    		
    		synchronized (sc) {
    			sc.notify();
    			sc.notify();
    		}
    		
    		while(true);

会打印：

thread1  
thread0

如果把其中的sc.notify()换为notifyAll()则会打印出所有的线程。

## interrupt ##

在阻塞的方法比如wait() 或者sleep()中会有while(interruped()) throws InterruptedException()方法，

interrupt()方法会设置状态为打断状态

interrupted()方法如果是打断状态返回true，同时设置打断状态为false;

## 生产者消费者 ##

public class Storage {
    	private String[] products = new String[2];
    	private int index = -1;
    	
    	public synchronized void  produce(String product) throws InterruptedException{
    		while(index == products.length - 1){
    			System.out.println("超出上限无法生产");
    			this.wait();
    		}
    		
    		products[++index] = product;
    		System.out.println("生产了" + product);
    		this.notify();
    	}
    	
    	public synchronized String consume() throws InterruptedException{
    		while(index == -1){
    			System.out.println("没有库存了");
    			this.wait();
    		}
    		this.notify();
    		return products[index--];
    	}
    	
    	public static void main(String[] args) {
    		final Storage s = new Storage();
    		new Thread(){
    			public void run() {
    				while(true){
    					try {
    						System.out.println("消费了" + s.consume());
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					
    					try {
    						TimeUnit.MILLISECONDS.sleep(new Random(1000).nextLong());
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			};
    		}.start();
    		
    		new Thread(){
    			public void run() {
    				while(true){
    					try {
    						s.produce("product" + new Random().nextInt(100));
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    					
    					try {
    						TimeUnit.MILLISECONDS.sleep(new Random(1000).nextLong());
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			};
    		}.start();
    		
    		while(true);
    	}
    }

一个线程生产，一个线程消费。

生产超出上限则wait消费，没超出则进行生产，开始生产了就应该通知消费者可以消费了。

消费线程没有商品则wait生产，有商品就消费，同时通知生产者可以继续生产了。

[Center]: /images/20220806/67daf16209b34159a81ce170650ca0b6.png