java线程简析

线程简析：

线程是正在运行程序进程中单一的执行流，一个进程对应一个程序，一个程序可以有多个进程，进程有自己的独立空间，线程只能共享进程中的空间，一个进程至少包含一个线程。线程最大的特点是可以同时并发执行多个任务。

比如程序要执行煮饭、洗菜、切菜、炒菜、吃饭五个方法，煮饭要20分钟，洗菜15分钟，切菜5分钟，炒菜15分钟，最后吃饭。在不使用线程时，程序执行这五个方法是窜起来，一个方法接一个方法去完成，总共要花20+15+5+15=55分钟，而使用线程时，程序的运行是这样的：在煮饭的时候CPU会有休眠的时间，这时CPU就会执行下一个方法即洗菜，洗菜的时候可能在接水时需要等待，那么CPU右可以执行下一个方法，按照这样的逻辑执行，这时程序的执行这五个方法就像人执行煮饭、洗菜、切菜、炒菜、吃饭这五个过程一样，合理和最大效率的完成这五件事情，也就是说使CPU的闲置时间减少，从而提高效率，节省时间。

 

实现多线程的方法：

继承Thread类

<pre name="code" class="java">public class MyThread extends Thread{
//重写run方法
public void run（）{
//要做的事
}
}

实现Runnable接口
public class MyThread implements Runnable{
//重写run方法
public void run（）{
//要做的事
}
}

下面用具体代码体现：
public class Man {	
	public static void main(String[] args) {
		Women men = new Women();
		//煮饭:启动煮饭线程
		CookieThread ct = new CookieThread();
		ct.start();//启动线程
		//洗菜
		WashThread wt = new WashThread();
		wt.start();
		//切菜
		CutThread cut = new CutThread();//创建线程对象
		Thread cutThread = new Thread(cut);//把线程对象包装成Thread对象
		cutThread.start();
		//炒菜
		FireThread fire = new FireThread();//创建线程对象
		Thread fireThread = new Thread(fire);//把线程对象包装成Thread对象
		fireThread.start();
		//吃饭
		men.eat();
	}
	public void eat(){
		System.out.println("开始吃饭了！");
	}
}

//煮饭类的线程
public class CookieThread extends Thread{
	public void run() {
		cookie();
	}
	/**
	 * 煮饭
	 */
	public void cookie(){
		System.out.println("开始煮饭.....");
		try {
			//休眠2秒
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("煮饭完成!");
	}
}

//洗菜类的线程
public class WashThread extends Thread{
	public void run() {
		wash();
	}
	/**
	 * 洗菜
	 */
	public void wash(){
		System.out.println("开始洗菜.....");
		try {
			//休眠2秒
			Thread.sleep(1500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("洗菜完成!");
	}
}

//切菜类的线程
public class CutThread implements Runnable{
	public void run() {
		cut();
	}
	/**
	 * 切菜
	 */
	public void cut(){
		System.out.println("开始切菜.....");
		try {
			//休眠2秒
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("切菜完成!");
	}
}

//炒菜类的线程
public class FireThread implements Runnable{
	public void run() {
		fire();
	}
	/**
	 * 炒菜
	 */
	public void fire(){
		System.out.println("开始炒菜.....");
		try {
			//休眠2秒
			Thread.sleep(1500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("炒菜完成!");
	}
}

Synchronized同步锁关键字、wait()方法、notify()方法：

用生产/消费模型说明：

public class Producter extends Thread{
	private ArrayList<Iphone> list;
	public Producter(ArrayList<Iphone> list){
		this.list = list;
	}
	
	public void run() {
		//定义一个计数器，来标志手机序列号
		int count = 0;
		synchronized (list) {
			while(true){
				//判断当前集合中是否还有手机
				if(list.size()>0){
					//说明集合中还有手机，不应该生产
					try {
						list.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				//生产手机
				Iphone ip = new Iphone("苹果5S"+count);
				count++;
				list.add(ip);
				System.out.println("生产商生产了一个手机，手机型号为："+ip.name);
				//通知消费者，不要再等待了，可以消费手机
				list.notify();
			}
		}
	}
}

Synchronized同步锁关键字、wait()方法、notify()方法：

用生产/消费模型说明：

public class Producter extends Thread{
	private ArrayList<Iphone> list;
	public Producter(ArrayList<Iphone> list){
		this.list = list;
	}
	
	public void run() {
		//定义一个计数器，来标志手机序列号
		int count = 0;
		synchronized (list) {
			while(true){
				//判断当前集合中是否还有手机
				if(list.size()>0){
					//说明集合中还有手机，不应该生产
					try {
						list.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				//生产手机
				Iphone ip = new Iphone("苹果5S"+count);
				count++;
				list.add(ip);
				System.out.println("生产商生产了一个手机，手机型号为："+ip.name);
				//通知消费者，不要再等待了，可以消费手机
				list.notify();
			}
		}
	}
}

public class Customer extends Thread{
	private ArrayList<Iphone> list;
	public Customer(ArrayList<Iphone> list){
		this.list = list;
	}
	public void run() {
		super.run();
		synchronized (list) {
			while(true){
				//访问仓库中的数据是否还有
				if(list.size()==0){
					//处于等待
					try {
						list.wait();//等待
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				//买手机
				Iphone ip = list.remove(0);
				//输出手机的型号
				System.out.println("买了一个手机，型号为："+ip.name);
				//告诉生产者，你可以生产手机
				list.notify();//通知
			}
		}
	}
}

public class Iphone {
	//定义属性
	public String name;
	public Iphone(String name){
		this.name = name;
	}
}

public class Test {
	public static void main(String[] args) {
		//定义一个集合仓库，用来存储共同访问的手机
		ArrayList<Iphone> list = new ArrayList<Iphone>();
		//创建生产线程
		Producter product = new Producter(list);
		//创建消费线程
		Customer customer = new Customer(list);
		//运行线程
		product.start();
		customer.start();
	}
}

运行结果为：

生产商生产了一个手机，手机型号为：苹果5S84620
买了一个手机，型号为：苹果5S84620
生产商生产了一个手机，手机型号为：苹果5S84621
买了一个手机，型号为：苹果5S84621
生产商生产了一个手机，手机型号为：苹果5S84622
买了一个手机，型号为：苹果5S84622
。。。。。。。。。

线程池：

线程的生命周期：

线程状态：

比如现在公司有五名员工，公司有一个任务列表，需要十名员工一起完成所有任务：

这五名员工是每个人随机获得一个任务，而且每名员工几乎是同时去获取完成任务

public class ThreadPool {
	//先定义一个容器，用来存储执行线程
	private PoolWorker[] workerArray = new PoolWorker[10];
	//定义一个容器，用来存储任务
	private ArrayList<MyTask> taskList = new ArrayList<MyTask>();
	
	public ThreadPool(){
		//预置好所有的执行线程
		for(int i=0;i<workerArray.length;i++){
			PoolWorker worker = new PoolWorker(taskList);
			worker.setName("第"+i+"号员工");
			workerArray[i] = worker;
			worker.start();//启动线程
			System.out.println(worker.getName()+"已经准备完毕，等待执行任务!");
		}
		System.out.println("******************线程池预置完毕**************************");
	}
	//分配任务到任务列表
	public void excute(MyTask task){
		synchronized (taskList) {
			taskList.add(task);
			//通知所有等待的线程，可以取任务了
			taskList.notify();
		}
	}
	
	public static void main(String[] args) {
		//1.先创建公司（线程池）
		ThreadPool pool = new ThreadPool();
		//分配任务
		for(int i=0;i<60;i++){
			MyTask task = new MyTask(i);
			pool.excute(task);
		}
	}
}

public class PoolWorker extends Thread{
	//所有工作线程共享同一份任务列表
	private ArrayList<MyTask> taskList;
	public PoolWorker(ArrayList<MyTask> taskList){
		this.taskList = taskList;
	}
	@Override
	public void run() {
		while(true){
			//同步关键字
			synchronized (taskList) {
				if(taskList.isEmpty()){
					try {
						taskList.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
			//取出一个任务，并执行
			MyTask task = taskList.remove(0);
			System.out.println(this.getName()+"开始执行"+task.index+"任务");
			//执行任务
			task.work();
		}
	}
}

public class MyTask {
	//任务编号
	public int index;
	public MyTask(int index){
		this.index = index;
	}
	public void work(){
		System.out.println(index+"号任务开始....");
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(index+"号任务结束!");
	}
}

输出结果为：

第0号员工已经准备完毕，等待执行任务!
第1号员工已经准备完毕，等待执行任务!
第2号员工已经准备完毕，等待执行任务!
第3号员工已经准备完毕，等待执行任务!
第4号员工已经准备完毕，等待执行任务!
******************线程池预置完毕**************************
第0号员工开始执行1任务
第3号员工开始执行3任务
第2号员工开始执行2任务
2号任务开始....
第4号员工开始执行1任务
1号任务开始....
3号任务开始....
1号任务开始....
第1号员工开始执行5任务
5号任务开始....
2号任务结束!
1号任务结束!
第2号员工开始执行5任务
5号任务开始....
3号任务结束!
5号任务结束!
1号任务结束!
5号任务结束!