第十三章 多线程 第二讲

第十三章 多线程 第二讲
二 线程的生命周期
线程是一个动态执行的过程，它也有一个从产生到死亡的过程，这就是所谓的生命周期。
生命周期的执行过程：
新建——》就绪——》运行——》死亡
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 intgetPriority();
设置优先级的方法：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 implementsRunnable{
private Stack1 s;
public Runner1(Stack1 s){
this.s=s;
}
@Override
public void run() {
// TODO Auto-generated methodstub
//拖延时间
for(inti=0;i<5;i++){
System.out.println(i+" ");
}
s.push('c');
}
}
//线程类Runner2中的run()方法从堆栈中弹出栈顶字符。
public class Runner2 implementsRunnable {
private Stack1 s;
public Runner2(Stack1 s){
this.s=s;
}
@Override
public void run() {
// TODO Auto-generated methodstub
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解锁。最终 的结果：两个线程互相等待，都无法运行。