Java之多线程总结

自己做一下笔记

 

1.创建线程启动对象

1.1继承Thread类创建并启动线程对象

public class ThreadSample extends Thread ｛
public static void main(String []args) {

ThreadSample threadSample = new ThreadSample();
threadSample.start();
}
public void run() {
//
System.out.println("This id a Thread Sample!");
}
}

start()方法用于启动线程对象，但并不是立即执行run方法，而是在条件允许时线程对象中的run方法将被自动执行。

1.2实现Runnable接口创建并启动线程对象

public class RunnableSample implements Runnable {
	public static void main(String []arg) {
		RunnableSample runnableSample = new RunnableSample();
		Thread thread = new Thread(runnableSample);
		thread.start();
		//new Thread(runnableSample).start();
	}
	public void run() {
		System.out.println("this is a runnable sample!");
	}
}

2.Java多线程机制

2.1线程对象生命周期和状态

关于线程生命周期的状态控制的详细讲解请打开链接：http://blog.csdn.net/lonelyroamer/article/details/7949969

2.2线程间的同步控制机制

多线程应用的一个重要领域就是线程间可以相互通信、传递信息、操作共享资源等，当设计多个线程操作一个公共对象是，每个线程是都可以独立操作公共对象的，一个java应用程序创建多个线程共同操作相同资源比较常见，而在同一时间里两个或多个线程共同访问共享资源也是经常发生的，但是在多个线程“同时”操作一个公共对象时就会存在线程之间协调共享资源以及线程之间的并发、阻塞、死锁等问题，Java指定的线程之间的同步控制机制就是使多个线程之间能够协调工作，避免线程本身存在的问题。

public synchronized void methodname() {
//....
}

在线程对象中某些操作可能产生线程问题时，可将他们放在synchronized修饰的方法体中，当线程对象中synchronized修饰的方法被调用时，相当于该线程进入了线程监视器并受到保护，其他试图调用进入线程监视器受保护对象中修饰为synchronized方法的线程对象都需要等待，自动进入等待状态，以此实现同步保护机制。

这里面规则还是比较多的，需要在实际编程中慢慢体会。

3.典型生产者消费者问题

 生产者-消费者（producer-consumer）问题，也称作有界缓冲区（bounded-buffer）问题，两个进程共享一个公共的固定大小的缓冲区。其中一个是生产者，用于将消息放入缓冲区；另外一个是消费者，用于从缓冲区中取出消息。问题出现在当缓冲区已经满了，而此时生产者还想向其中放入一个新的数据项的情形，其解决方法是让生产者此时进行休眠，等待消费者从缓冲区中取走了一个或者多个数据后再去唤醒它。同样地，当缓冲区已经空了，而消费者还想去取消息，此时也可以让消费者进行休眠，等待生产者放入一个或者多个数据时再唤醒它。

<pre name="code" class="java">package com.practice;

/**
 * Java线程：并发协作-生产者消费者模型
 * 
 * @author
 */
public class Producer_Consumer {
	public static void main(String[] args) {
		Godown godown = new Godown(30);
		Consumer c1 = new Consumer(50, godown);
		Consumer c2 = new Consumer(20, godown);
		Consumer c3 = new Consumer(30, godown);
		Producer p1 = new Producer(10, godown);
		Producer p2 = new Producer(20, godown);
		Producer p3 = new Producer(10, godown);
		Producer p4 = new Producer(10, godown);
		Producer p5 = new Producer(30, godown);
		Producer p6 = new Producer(10, godown);
		Producer p7 = new Producer(30, godown);

		c1.start();
		c2.start();
		c3.start();
		p1.start();
		p2.start();
		p3.start();
		p4.start();
		p5.start();
		p6.start();
		p7.start();
	}
}

/**
 * 仓库
 */
class Godown {
	public static final int max_size = 100; // 最大库存量
	public int curnum; // 当前库存量

	Godown() {
	}

	Godown(int curnum) {
		this.curnum = curnum;
	}

	/**
	 * 生产指定数量的产品
	 * 
	 * @param neednum
	 */
	public synchronized void produce(int neednum) {
		// 测试是否需要生产
		while (neednum + curnum > max_size) {
			System.out.println("要生产的产品数量" + neednum + "超过剩余库存量"
					+ (max_size - curnum) + "，暂时不能执行生产任务!");
			try {
				// 当前的生产线程等待
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// 满足生产条件，则进行生产，这里简单的更改当前库存量
		curnum += neednum;
		System.out.println("已经生产了" + neednum + "个产品，现仓储量为" + curnum);
		// 唤醒在此对象监视器上等待的所有线程
		notifyAll();
	}

	/**
	 * 消费指定数量的产品
	 * 
	 * @param neednum
	 */
	public synchronized void consume(int neednum) {
		// 测试是否可消费
		while (curnum < neednum) {
			System.out.println("现有库存量"+curnum+",要消费的产品数量" + neednum + ",只能消费"
					+ curnum + "个产品");
			curnum = 0;
			try {
				// 当前的生产线程等待
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		// 满足消费条件，则进行消费，这里简单的更改当前库存量
		curnum -= neednum;
		System.out.println("已经消费了" + neednum + "个产品，现仓储量为" + curnum);
		// 唤醒在此对象监视器上等待的所有线程
		notifyAll();
	}
}

/**
 * 生产者
 */
class Producer extends Thread {
	private int neednum; // 生产产品的数量
	private Godown godown; // 仓库

	Producer(int neednum, Godown godown) {
		this.neednum = neednum;
		this.godown = godown;
	}

	public void run() {
		// 生产指定数量的产品
		godown.produce(neednum);
	}
}

/**
 * 消费者
 */
class Consumer extends Thread {
	private int neednum; // 生产产品的数量
	private Godown godown; // 仓库

	Consumer(int neednum, Godown godown) {
		this.neednum = neednum;
		this.godown = godown;
	}

	public void run() {
		// 消费指定数量的产品
		godown.consume(neednum);
	}
}

现有库存量30,要消费的产品数量50,只能消费30个产品
已经生产了10个产品，现仓储量为10
现有库存量10,要消费的产品数量30,只能消费10个产品
已经生产了20个产品，现仓储量为20
已经生产了30个产品，现仓储量为50
已经生产了30个产品，现仓储量为80
已经生产了10个产品，现仓储量为90
已经生产了10个产品，现仓储量为100
要生产的产品数量10超过剩余库存量0，暂时不能执行生产任务!
已经消费了20个产品，现仓储量为80
已经生产了10个产品，现仓储量为90
已经消费了30个产品，现仓储量为60
已经消费了50个产品，现仓储量为10