对线程的总结
1:创建线程
实现线程有两种方式。1,继承Thread,2,实现Runnable接口。
(1) 继承Thread类,重写里面的public void run()方法,然后创建实例对象。调用start()方法开启线程。
//创建线程对象
Public class TestThread extends Thread{
Public void run(){
}
}
New TestThread().start();//开启线程
//用匿名类创建开始线程。
New Thread(){
Public void run(){
}
}.start();
(2) 实现Runnable接口。实现pubilv void run()方法.
然后创建实现类对象。通过Thread(Runnable run)实例化线程对象,最后调用start()方法开启线程。
解析:java只支持单线程。既一个子类只有一个父类。如果想继承某个类。又想实现多线程。就得用Runnable接口来创建线程。
//实现线程
Public class TestThread implementsRunnable{
Public void run(){
}
}
TestThread test = newTestThread();
New Thread(test).start();//开启线程
(3) Thread和Runnable的比较;
1:Runnable没有start()方法、
2:Runnable避免点继承的局限,一个类可以继承多个接口、
3:Runnable适合资源共享。
同一个thread对象不能多次实例化。因为他的资源不能 共享。也就是说不能多次调用start()方法。
4 结论
一般用Runnable去实现线程。因为扩展性好。也能实现
资源共享。、
2:线程的特点
1 :运行java程序。最少有两个线程,一个是Main()方法线程,另一个是垃圾回收(GC)线程。
2:线程的常用方法
IsAlive()判断线程是否在活动
SetName(),getName();设置(可在运行时设置)和得到线程的名字
SetDaemon(true);设置为后台线程
注:后台线程会随进程的主线程结束而停止
Join();强制插入当前线程执行完成。也可以join(long time)精确到毫秒执行
Intertuped();中断线程。遇到sleep(),join会扑捉线程中断异常
3、线程状态
线程的状态转换是线程控制的基础。线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下:
1、新状态:线程对象已经创建,还没有在其上调用start()方法。
2、可运行状态:当线程有资格运行,但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时,线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后,也返回到可运行状态。
3、运行状态:线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。
4、等待/阻塞/睡眠状态:这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种,其共同点是:线程仍旧是活的,但是当前没有条件运行。换句话说,它是可运行的,但是如果某件事件出现,他可能返回到可运行状态。
5、死亡态:当线程的run()方法完成时就认为它死去。这个线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦死亡,就不能复生。如果在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。
有关详细状态转换图可以参看本人的“Java多线程编程总结”中的图
二、阻止线程执行
对于线程的阻止,考虑一下三个方面,不考虑IO阻塞的情况:
睡眠;
等待;
因为需要一个对象的锁定而被阻塞。
1、睡眠
Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠(暂停执行),以“减慢线程”。当线程睡眠时,它入睡在某个地方,在苏醒之前不会返回到可运行状态。当睡眠时间到期,则返回到可运行状态。
线程睡眠的原因:线程执行太快,或者需要强制进入下一轮,因为Java规范不保证合理的轮换。
睡眠的实现:调用静态方法。
try {
Thread.sleep(123);
} catch (InterruptedException e) {
e.printStackTrace();
}
睡眠的位置:为了让其他线程有机会执行,可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠。
例如,在前面的例子中,将一个耗时的操作改为睡眠,以减慢线程的执行。可以这么写:
public void run() {
for(int i = 0;i<5;i++){
// 很耗时的操作,用来减慢线程的执行
// for(long k= 0; k <100000000;k++);
try {
Thread.sleep(3);
} catch (InterruptedExceptione) {
e.printStackTrace();.
}
System.out.println(this.getName()+" :"+i);
}
}
运行结果:
阿三 :0
李四 :0
阿三 :1
阿三 :2
阿三 :3
李四 :1
李四 :2
阿三 :4
李四 :3
李四 :4
Process finished with exit code 0
这样,线程在每次执行过程中,总会睡眠3毫秒,睡眠了,其他的线程就有机会执行了。
注意:
1、线程睡眠是帮助所有线程获得运行机会的最好方法。
2、线程睡眠到期自动苏醒,并返回到可运行状态,不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此,sleep()方法不能保证该线程睡眠到期后就开始执行。
3、sleep()是静态方法,只能控制当前正在运行的线程。
2、线程的优先级和线程让步yield()
线程的让步是通过Thread.yield()来实现的。yield()方法的作用是:暂停当前正在执行的线程对象,并执行其他线程。
要理解yield(),必须了解线程的优先级的概念。线程总是存在优先级,优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下,当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。
注意:当设计多线程应用程序的时候,一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的,只能把线程优先级作用作为一种提高程序效率的方法,但是要保证程序不依赖这种操作。
当线程池中线程都具有相同的优先级,调度程序的JVM实现自由选择它喜欢的线程。这时候调度程序的操作有两种可能:一是选择一个线程运行,直到它阻塞或者运行完成为止。二是时间分片,为池内的每个线程提供均等的运行机会。
设置线程的优先级:线程默认的优先级是创建它的执行线程的优先级。可以通过setPriority(intnewPriority)更改线程的优先级。例如:
Thread t = new MyThread();
t.setPriority(8);
t.start();
线程优先级为1~10之间的正整数,JVM从不会改变一个线程的优先级。然而,1~10之间的值是没有保证的。一些JVM可能不能识别10个不同的值,而将这些优先级进行每两个或多个合并,变成少于10个的优先级,则两个或多个优先级的线程可能被映射为一个优先级。
线程默认优先级是5,Thread类中有三个常量,定义线程优先级范围:
static int MAX_PRIORITY
线程可以具有的最高优先级。
static int MIN_PRIORITY
线程可以具有的最低优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。
3、Thread.yield()方法
Thread.yield()方法作用是:暂停当前正在执行的线程对象,并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。
结论:yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下,yield()将导致线程从运行状态转到可运行状态,但有可能没有效果。