一、线程的优先级
1、把线程从就绪状态进入运行状态的过程叫做线程调度。负责调度工作的机构叫做调度管理器。
2、优先级:线程的优先级的取值范围是1~10。
MAX_PRIORITY = 10
NORM_PRIORITY = 5
MIN_PRIORITY = 1
3、得到或修改线程的优先级
public final int getPriority();
public final void setPriority(int newPriority);
二、常用方法
1、线程睡眠sleep ()
执行该方法可使当前线程睡眠(停止执行)若干毫秒,线程由运行状态进入不可运行状态,睡眠时间过后线程再次进入可运行状态。
2、暂停状态yield ()静态方法
Yield()方法的优点是保证有工作时不会让CPU闲置,主要用于编写多个合作线程,也适用于强制线程间的合作。
3、连接线程join() 普通方法
调用join()方法可使当前线程暂停执行,等待调用该方法的线程结束后再继续执行本线程。
void run() //创建该类的子类时必须实现的方法
void start() //开启线程的方法
static void sleep(long t) //释放CPU的执行权,不释放锁
static void sleep(long millis,int nanos)
final void wait()//释放CPU的执行权,释放锁
final void notify()
static void yied()//可以对当前线程进行临时暂停(让线程将资源释放出来)
public final void stop()//结束线程,但由于安全的原因过时
public final void join()
public final void join(long millis)
public final void join(long millis,int nanos)
注意:
结束线程原理:就是让run方法结束。而run方法中通常会定义循环结构,所以只要控制住循环即可。
方法----可以boolean标记的形式完成,只要在某一情况下将标记改变,让循环停止即可让线程结束。但是,特殊情况,线程在运行过程中,处于了冻结状态,是不可能读取标记的。
那么这时,可以通过正常方式恢复到可运行状态,也可以强制让线程恢复到可运行状态,通过Thread类中的,interrupt():清除线程的冻结状态,但这种强制清除会发生InterruptedException。所以在使用 wait,sleep,join方法的时候都需要进行异常处理。
public final void join()//让线程加入执行,执行某一线程join方法的线程会被冻结,等待某一线程执行结束,该线程才会恢复到可运行状态
public final boolean isAlive()
将线程标记为守护线程(后台线程):setDaemon(true); 注意该方法要在线程开启前使用。和前台线程一样开启,并抢资源运行,所不同的是,当前台线程都结束后,后台线程会自动结束。无论后台线程处于什么状态都会自动结束。
13.4 线程的同步
一、为什么需要“线程同步”
线程间共享代码和数据可以节省系统开销,提高程序运行效率,但同时也导致了数据的“访问冲突”问题,如何实现线程间的有机交互、并确保共享资源在某些关键时段只能被一个线程访问,即所谓的“线程同步”(Synchronization)就变得至关重要。
二、临界资源
多个线程间共享的数据称为临界资源(Critical Resource),由于是线程调度器负责线程的调度,程序员无法精确控制多线程的交替顺序。因此,多线程对临界资源的访问有时会导致数据的不一致行。
实例:使用临界资源。
堆栈类,类中封装字符数组data作为堆栈的区域,push()和pop()方法完成堆栈的压入和弹出。Index用于标识栈顶位置 |
private char[] data=new char[10];
private int index=0;
public void push(char ch){
data[index]=ch;
System.out.println("压入字符"+ch+"-->");//p1
index++;
System.out.println("-->压入"+ch+"操作完成!");
}
public char pop(){
index--;
return data[index];
}
}
public class Runner1 implements Runnable{
private Stack s;
public Runner1(Stack s){
this.s=s;
}
@Override
public void run() {
for(int i=0;i<4;i++){
System.out.println(i+" ");
线程类Runner1中的run()方法向堆栈中压入了字符’c’。
|
s.push('c');
}
}
public class Runner2 implements Runnable {
private Stack s;
public Runner2(Stack s){
线程类Runner2中的run()方法从堆栈中弹出栈顶字符。
|
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("***弹出"+s.pop()+"***");
}
}
public class TestCritical {
public static void main(String[] args){
Stack s=new Stack();
对象s即为临界资源,是线程t1和t2间共享的数据
|
s.push('b');
Runner1 r1=new Runner1(s);
Runner2 r2=new Runner2(s);
Thread t1=new Thread(r1);
Thread t2=new Thread(r2);
线程t1向临界资源s压入字符’c’,线程t2从临界资源s中弹出数据。
|
t2.start();
}
}
三、互斥锁
a) 每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
b) Java对象默认是可以被多个线程共用的,只是在需要时才启动“互斥锁”机制,成为专用对象。
c) 关键字synchronized用来与对象的互斥锁联系
d) 当某个对象用synchronized修饰时,表明该对象已启动“互斥锁”机制,在任一时刻只能由一个线程访问,即使该线程出现堵塞,该对象的被锁定状态也不会解除,其他线程任不能访问该对象。
e)
public synchronized char pop(){ index--; return data[index]; }
|
i.
同步代码块可以使用任意对象作为锁,同步方法使用的锁只有一个--this。static同步方法使用的锁是该方法所属类的对象。类型.class
|
public void push(char c){
…
sychronized(this){
data[index]=c;
index++
}
}
ii. 用在方法声明中,表示整个方法为同步方法
同步好处:决了线程安全问题
同步弊端
降低了运行效率(判断锁是较为消耗资源的)
同步嵌套,容易出现死锁
四、死锁
两个线程A、B用到同一个对象s(s为共享资源),且线程A在执行中要用到B运行后所创造的条件。在这种前提下A先开始运行,进入同步块后,对象s被锁定,接着线程A因等待B运行结束而进入阻塞状态,于是B开始运行,但因无法访问对象s,线程B也进入阻塞状态,等待s被线程A解锁。最终的结果:两个线程互相等待,都无法运行。
五、线程同步通信
为避免死锁,就应该让线程在进入阻塞状态时尽量释放其锁定的资源,以为其他的线程提供运行的机会,Object类中定义了几个有用的方法:wait()、notify()、notifyAll()。
wait():被锁定的对象可以调用wait()方法,这将导致当前线程被阻塞并释放该对象的互斥锁,即解除了wait()方法当前对象的锁定状态,其他的线程就有机会访问该对象。
notify():唤醒调用wait()方法后被阻塞的线程。
notifyAll():唤醒所有调用wait()方法被阻塞的线程。