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

目录

• 并行和并发
• 线程基础概念

• 线程和进程
• 多线程的好处
• 线程的状态

• 继承Thread类
• 实现Runnable接口

• 生产消费者模型中的类–存储类
• 生产消费者模型中的类–生产者
• 生产消费者模型中的类–消费者
• 测试类
• 效果

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();	
	}
}