第十三章 多线程 第二讲

第十三章 多线程 第二讲

二 线程的生命周期

线程是一个动态执行的过程，它也有一个从产生到死亡的过程，这就是所谓的生命周期。

生命周期的执行过程：

新建——》就绪——》运行——》死亡

1．生命周期的举例与分析

（1）新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。
例如：Thread t1=new Thread();

（2）就绪（runnable）
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();

（3）运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

（4）死亡（dead）
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

自然终止：正常运行run()方法后终止

异常终止：调用stop()方法让一个线程终止运行

（5）堵塞（blocked）
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。

（1）正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

（2）正在等待：调用wait()方法。（调用motify()方法回到就绪状态）

被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

2．线程的优先级

把线程从就绪状态进入运行状态的过程叫做线程调度。负责调度工作的机构叫做调度管理器

优先级：线程的优先级的取值范围是1~10，1的优先级最高，默认的优先级是5。
public static final int MAX_PRIORITY = 10
public static final int NORM_PRIORITY = 5
public static final int MIN_PRIORITY = 1

`` 获取优先级的方法：public final int getPriority();

设置优先级的方法：public final void setPriority(int newPriority);

优先级的创建：MyThread mt = new MyThread(“thread”,8);

注：“thread”是线程的名字，8 是优先级的设置

注：如果有多个线程在等待，并不是优先级别高的就肯定越早执行，只是获得的机会更对一些，因此在通常情况下，不要依靠线程优先级来控制线程的状态.

3．在线程调度时，用到的方法有：

(1)void run() //创建该类的子类时必须实现的方法

(2)void start() //开启线程的方法

(3)static void sleep(long t) //释放CPU的执行权，不释放锁

(4)static void sleep(long millis,int nanos) //（秒数，纳秒数）

(5)final void wait()//释放CPU的执行权，释放锁

(6)final void notify()//它与wait()一起使用

(7)static void yield()------暂停线程

yield()方法可以对当前线程进行临时暂停（让线程将资源释放出来），允许其它线程的执行。该线程仍处于可运行的状态，不转变为阻塞状态，它的优点是：保证有工作时不会让CPU闲置，主要用于编写多个合作线程，也适用于强制性线程间的合作。

注：在使用此方法时，设置为真或者假，是否可执行,代码显示：

If(flag){ //此时flag是一个boolean类型的值，传的是true 继续执行，

Thread.yield(); //

}

pulbic void run(){

long start = new Date().getTime();//获取当前的时间并付给long

for(int i=0;i<1000;i++){

If(flag){

Thread.yield();//暂停线程

For(int j=0;j<3000;j++){

;

}

}

long end = new Date().getTime();

System.out.println(this.getName()+”执行时间”+(end-start));

}

(8)public final void stop()//结束线程，但由于安全的原因过时

(9)join()----连接线程

连接线程是指使当前的线程阻塞，让出CPU的位置，从而加入正在等待的线程。

（10）interrupt()方法只是为线程设置了一个中断标记，并没有中断线程的运行，一个线程在别设置了此方法后，仍可以执行，isAlive()返回的是true，如果遇到了此方法抛出异常---InterruptException,会结束程序的运行。

四 线程的同步

1．为什么需要“线程同步”
线程间共享代码和数据可以节省系统开销，提高程序运行效率，但同时也导致了数据的“访问冲突”问题，如何实现线程间的有机交互、并确保共享资源在某些关键时段只能被一个线程访问，即所谓的“线程同步”(Synchronization)就变得至关重要。

临界资源
多个线程间共享的数据称为临界资源(Critical Resource)，由于是线程调度器负责线程的调度，程序员无法精确控制多线程的交替顺序。因此，多线程对临界资源的访问有时会导致数据的不一致行。

正因为有这些原因，所以在实现多线程同步时，每个对象都应该有个“互斥锁“这个标记用来保证在任一时刻，只能有一个线程访问该对象。关键字synchronized用来与对象的互斥锁联系

实例：

//使用临界资源

public class Stack1 {

private char[] data=new char[10];

private int index=0;

//堆栈的压入

public void push(char ch){

//锁定正在执行的多线程，指会执行这一个，等它执行完之后，在执行等待的线程

synchronized(this){

data[index]=ch;

System.out.println("压入字符"+ch+"-->");//p1

index++;//每压入一个字符索引下标加1，用于标识栈顶位置

System.out.println("-->压入"+ch+"操作完成！");

}

}

//堆栈的弹出

public char pop(){

index--;

return data[index];

}

//线程类Runner1中的run()方法向堆栈中压入了字符’c’。

public class Runner1 implements Runnable{

private Stack1 s;

public Runner1(Stack1 s){

this.s=s;

}

@Override

public void run() {

// TODO Auto-generated method stub

//拖延时间

for(int i=0;i<5;i++){

System.out.println(i+" ");

}

s.push('c');

}

}

//线程类Runner2中的run()方法从堆栈中弹出栈顶字符。

public class Runner2 implements Runnable {

private Stack1 s;

public Runner2(Stack1 s){

this.s=s;

}

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("***弹出"+s.pop()+"***");

}

}

//测试类

public class TestCritical {

public static void main(String[] args){

Stack1 s=new Stack1();

s.push('a');

s.push('b');

Runner1 r1=new Runner1(s);

Runner2 r2=new Runner2(s);

Thread t1=new Thread(r1);

Thread t2=new Thread(r2);

t1.start();

t2.start();

}

}

2. 同步好处：决了线程安全问题

同步弊端:

降低了运行效率（判断锁是较为消耗资源的）

同步嵌套，容易出现死锁

死锁
两个线程A、B用到同一个对象s(s为共享资源)，且线程A在执行中要用到B运行后所创造的条件。在这种前提下A先开始运行，进入同步块后，对象s被锁定，接着线程A因等待B运行结束而进入阻塞状态，于是B开始运行，但因无法访问对象s，线程B也进入阻塞状态，等待s被线程A解锁。最终的结果：两个线程互相等待，都无法运行。