黑马程序员_java基础_多线程学习笔记

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

在Java中想要实现多线程机制有两种方式：1.继承Thread类  2.实现Runnable接口，但是想要启动线程，必须使用Thread类中的start()方法（可能不太准确，因为jdk1.5之后还有新的操作方式）。

下面代码来展示线程的两种启动方式：        

package com.itheima.com;

/**
 * 多线程
 */
public class MutiThread {

	public static void main(String[] args) {
		ThreadDemo demo1 = new ThreadDemo();
		demo1.start();// 启动线程

		//依靠Thread的start()方法启动线程
		new Thread(new RunnableDemo()).start();
		for (int i = 0; i < 100; i++)
			System.out.println("主线程");

	}
}

/**
 * 方式一
 */
class ThreadDemo extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++)
			System.out.println("方式一");
	}
}

class RunnableDemo implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++)
			System.out.println("方式二");
	}
}

注意：线程的start()方法在线程没有执行完毕之前只能调用一次，否则就会出现异常：java.lang.IllegalThreadStateException。也就是说，当前的线程处于启动状态，不能在此启动。

两种创建线程方式的区别：
在继承Thread类实现多线程不太适用于资源的共享，而实现Runnable接口，很方便的实现资源的共享。（不废话：看下如下代码的实现）

package com.itheima.com;

/**
 * 多线程
 */
public class MutiThread {

	public static void main(String[] args) {
		//如下：启动两次线程，但是Thread对象不是同一个，所以这种方式不能实现资源的共享
		new ThreadDemo().start();
		new ThreadDemo().start();
		
		//Runnable接口方式
		//两次启动线程，操作的是同一个Runnable对象
		RunnableDemo demo = new RunnableDemo();
		new Thread(demo).start();
		new Thread(demo).start();
	}
}

/**
 * 方式一
 */
class ThreadDemo extends Thread {
	private int i = 100;
	@Override
	public void run() {
		while(i>0)
			System.out.println("方式一："+i--);
	}
}

class RunnableDemo implements Runnable {
	private int i = 100;
	@Override
	public void run() {
		while(i>0)
			System.out.println("方式二："+i--);
	}
}

上述代码也不能说继承了Thread类之后就无法实现资源的共享的，可以使用静态成员变量的方式实现（原理：就是静态成员，在类实例化之前已经存在，并且只存在一份），修改ThreadDemo中的成员变量private int i = 100 变为 private static int i = 100;  当然，上述这段代码在运行的过程中会存在问题的，这也就是线程安全的问题。

Thread类的常用API：start() ：启动线程、sleep(long)：线程休眠、(s ) currentThread()：静态方法，得到当前正在执行的线程、setDaemon(boolean)：设置后台线程，在start()方法调用之前使用，等。。这些API在这里面写，感觉。。参见：javaSE在线文档

线程的其他操作：等待与唤醒，等待与唤醒是Object类中的方法，wait()、wait(long ) 、wait(long ,int)、notify()、notifyAll()这几个方法是对线程的支持。具体使用方式：会在生产者与消费者的案例中学习

线程安全问题：经典案例（多窗口售票）

在多窗口售票的情景中，多窗口，相当于同时开启了多个线程，来同时操作【共享】一份数据车票，但是车票的数量是有限制的，必须在有票的情况下才能被各个窗口出售，此时需要使用到同步关键字：synchronized，（表达能力不好，光是代码的话感觉很。。好吧，还是代码解释吧）

package com.itheima.thread;

import java.util.concurrent.TimeUnit;

/**
 * 线程的安全 同步关键字的使用场景：多个线程同时操作同一资源
 */
public class MutiThread {

	public static void main(String[] args) {
		RunnableDemo demo = new RunnableDemo();
		new Thread(demo).start();
		new Thread(demo).start();
		new Thread(demo).start();
		new Thread(demo).start();
		new Thread(demo).start();
		new Thread(demo).start();
	}
}

class RunnableDemo implements Runnable {
	private int ticketNum = 100;// 车票编号,实现Runnable接口，数据很方便进行共享

	@Override
	public void run() {
		while (true) {
			synchronized (this) {//同步关键字需要在共享资源访问是使用
				if (ticketNum > 0) {
					try {
						// 为了效果明显，加入线程的休眠操作
						TimeUnit.SECONDS.sleep(1);// 等同于 Thread.sleep(1000);
						//Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "卖出了第 " + ticketNum-- + " 张票");
				} else {
					System.out.println(Thread.currentThread().getName()
							+ "说：票没了");
					break;
				}
			}
		}
	}
}

注意：线程锁机制中，静态方法使用到的锁对象是---类名.class ，非静态方法与同步块使用到的锁对象是this

练习：生产者与消费者模型案例
设计一个生产电脑，搬运电脑的类，要求生产出一台电脑就搬走，如果没有生产出来，搬运者需要等待生产者生产出后在搬走，如果没有搬走，生产者需要等待搬运者搬完之后再开始生产。

package com.itheima.thread;

/**
 * 生产者与消费者测试类
 *
 */
public class ProducerAndConsumerDemo {
	
	public static void main(String[] args) {
		Computer computer = new Computer();
		Producer producer = new Producer(computer);
		Consumer consumer = new Consumer(computer);
		new Thread(producer).start();
		new Thread(producer).start();
		new Thread(consumer).start();
		new Thread(producer).start();
		new Thread(consumer).start();
		new Thread(consumer).start();
	}

}

/**
 * 电脑实体类
 */
class Computer{

	private boolean existComputer = false;//是否存在电脑
	private int currentNumber;
	
	/**
	 * 生产电脑，因为多个线程会执行生产方法，所以需要同步
	 */
	public synchronized void produce(){
		//如果存在电脑，那么就会等待搬运者搬运
		while(existComputer){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		//开始生产
		System.out.println("生产者 " + Thread.currentThread().getName() + "  生产了一台编号为："+ ++currentNumber + " 的电脑");
		//修改标志位
		this.existComputer = true;
		this.notifyAll();//唤醒所有线程
	}
	
	/**
	 * 搬运电脑
	 */
	public synchronized void consume(){
		while(!existComputer){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("消费者 "+ Thread.currentThread().getName() + " 消费了编号为：" + currentNumber + " 的电脑");
		//修改标志位
		existComputer = false;
		this.notifyAll();
	}
}

class Producer implements Runnable{
	private Computer computer;
	public Producer(Computer computer){
		this.computer = computer;
	}
	@Override
	public void run() {
		while(true){
			computer.produce();
		}
	}
}

class Consumer implements Runnable{
	private Computer computer;
	public Consumer(Computer computer){
		this.computer = computer;
	}
	@Override
	public void run() {
		while(true){
			computer.consume();
		}
	}
}

在jdk1.5之后增加了Lock接口与Condition接口来替换了synchronized 与 Object中的wait()、notity()、notifyAll() 方法，jdk1.5的新特性中因为一个Lock对象可以绑定多个Condition对象，所有锁的操作都是显式进行的，所以对于死锁的发生有很好的防止作用。（总结中有什么不对的地方，请大家指正。）

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net