黑马程序员_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