一文精通Java 多线程之全方位解读

public class ThreadDemo extends Thread{
	
	

	/**
	 * 继承Thread
	 * 
	 * @author gavin
	 *
	 */
	
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		//打印10次世界
			try {
				for(int i=0;i<10;i++) {
					System.out.print("世界");
					Thread.sleep(200);//阻塞态 休息200毫秒
				}		
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		System.out.println("线程执行完成！");				
	}
	
	
	public static void main(String[] args) {
		
		//初始化线程t1 t2
		ThreadDemo t1 = new ThreadDemo();
		ThreadDemo t2 = new ThreadDemo();
		//启动线程
		t1.start();
		t2.start();
		//注意不是调用run方法 而是启动线程 调用run方法只是执行了run方法但不是多线程执行
		
		//打印200次你好
		for(int i = 0;i<20;i++) {
			System.out.print("你好");
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
		
		//结束态
		System.out.println("程序运行完成");
		
		
		
		
	}
	
	
	
	

}

/**
 * 实现二： 实现Runnable接口
 * 当类本身有父类的时候 使用实现Runnable接口
 * @author gavin
 *
 */
public class RunnableDemo implements Runnable {

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		//打印10次世界
		try {
			for(int i=0;i<10;i++) {
				System.out.print(Thread.currentThread().getName()+"世界t");
				if(i%3==0) {
					System.out.println();
				}
				Thread.sleep(200);//阻塞态 休息200毫秒
			}		
	} catch (InterruptedException e) {
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
	System.out.println(Thread.currentThread().getName()+"线程执行完成！");			
		
	}
	
	public static void main(String[] args) {
		
		//实列化当前类 
		RunnableDemo runnableDemo1 = new RunnableDemo();
		
		//创建线程 传入任务类
		Thread t1 = new Thread(runnableDemo1);
		Thread t2 = new Thread(runnableDemo1);
		Thread t3 = new Thread(runnableDemo1);
			
		//设置线程优先级
		t1.setPriority(Thread.MAX_PRIORITY);//最高优先级
		t2.setPriority(Thread.MIN_PRIORITY);//最低优先级
		t3.setPriority(5);//设置默认优先级 优先级为5 优先级从0-10最高为10
		
		//启动线程
		t1.start();
		t2.start();
		t3.start();
		
		
	}	

}

synchronized(object){
}

public synchronized void method() {
// do something
}

import java.util.LinkedList;

public class Store {
	
	
	/*
	 * 存储 队列实现 
	 * 
	 * @author gavin
	 * */
	
	//创建队列
	LinkedList<Integer> list = new LinkedList<Integer>();
	
	//设置最大存储值
	int max = 10;
	
	//生产者生产 放入队尾
	public void push(int n) {
		
		synchronized(list) {
			try {
				if(list.size()>=max){
						System.out.println("存满了");				
					    //线程挂起	
						list.wait();
					}else {
						//队列没有存满 继续存
						System.out.println("存入："+n);
						list.add(n);
						//放完之后必须有 因此唤醒取的线程  
						list.notifyAll();					
					}
				
				
			}catch (Exception e) {
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}				
		}
		
		
	}
	
	
	//消费者消费 从队头取出
	public int pop() {
		try {
			synchronized(list){
				if(list.size()<=0) {
					System.out.println("队列空了。。。。");
					//空了之后就不能取了 因此线程挂起
					list.wait();
				}else {
					//从对头取出
					int n = list.poll();
					System.out.println("取出:"+n);
					//取出了就一定不会满 因此要唤醒线程
					list.notifyAll();
					return n;
					
				}								
			}
						
		}catch (Exception e) {
			// TODO: handle exception
		}	
		
		return 0;
	}
	
	
	
	
	
	
	
	
	

}

/**
 * 生产者
 */

public class Producer  implements Runnable{

	private Store store;
	
	public Producer(Store store) {
		// TODO 自动生成的构造函数存根
		this.store = store;
	}
	
	
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		try {
			//生产需要事件 休息100毫秒再生产
			Thread.sleep(100);
			//产生随机数字
			store.push((int)(Math.random()*100));
		}catch (Exception e) {
			// TODO: handle exception
			
		}
		
			
	}
	

}

public class Customer implements Runnable{

	
	private Store store;
	
	public Customer(Store store) {
		// TODO 自动生成的构造函数存根
		this.store = store;
	}
	
	

	@Override
	public void run() {
		// TODO 自动生成的方法存根
		try {
			//消费者消费需要时间 休息200毫秒
			Thread.sleep(200);
			//从队头取出
			store.pop();
		}catch (Exception e) {
			// TODO: handle exception
		}
	}

}

package com.qingsu.pcm;

public class TestPcm {

	public static void main(String[] args) {
		Store store = new Store();
		
		while(true) {
			Producer producer = new Producer(store);
			Customer customer = new Customer(store);
			
			Thread t1 = new Thread(producer);
			Thread t2 = new Thread(customer);
			
			t1.start();
			t2.start();
			
		}
		
	}
	
	
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPcmTwo {
		
/*
 * 利用线程池创建线程
*/
	
	
	public static void main(String[] args) {
		Store store = new Store();
		
		


		//创建10个线程的线程池
		ExecutorService service = Executors.newFixedThreadPool(10);
		ExecutorService serviceTwo = Executors.newFixedThreadPool(10);
		
		//创建可缓存的线程池
		//可缓存的
		//ExecutorService service = Executors.newCachedThreadPool();
		//ExecutorService serviceTwo = Executors.newCachedThreadPool();
		
		for(int i =0 ;i<11;i++) {
			service.execute(new Producer(store));
			
		}
		for(int i =0 ;i<11;i++) {
			serviceTwo.execute(new Customer(store));			
		}
			
		
		
		
		//关闭线程池
			service.shutdown();
			serviceTwo.shutdown();	
	}

}