0%

Java线程知识点(二)线程的构造和运行

① 用Thread类构造线程对象(继承Thread类来创建并启动多线程)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package cn.sxt.thread;

/**
* 创建线程方式一:
* 1、创建:继承Thread+重写run
* 2、启动:创建子类对象+start
* @author 1979
*
*/

public class StartThread extends Thread{

/**
* 线程入口点
*/
@Override
public void run() {
for(int i=0;i<20;i++) {
System.out.println("一边听歌");
}
}
public static void main(String[] args) {

/* 如果放在这里,那么要先敲完代码再听歌,for循环结束后才启动线程
* for(int i=0;i<20;i++) {
* System.out.println("一边coding");
* }
*/

//创建子类对象
StartThread st = new StartThread();
//启动
st.start();//不保证立即运行 由cpu调用
//st.run();//普通方法调用,只能听完歌再敲代码
for(int i=0;i<20;i++) {
System.out.println("一边coding");
}
}
}

【运行结果】

1
2
3
4
5
6
7
8
一边coding
一边coding
...
一边听歌
一边听歌
...
一边coding
一边coding

【缺点】由于java采用单继承机制,若为实现多线程而继承了Thread,将无法再继承其他类,是非常不明智的做法。

② 用Runnable辅助构造线程(实现Runnable接口创建线程类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package cn.sxt.thread;

/***
* 创建线程方式二
* 1、创建:实现Runnable+重写run
* 2、启动:创建实现类对象+Thread对象+start
*
* 推荐:避免单继承的局限性,优先使用接口
* 方便共享资源
* @author 1979
*
*/
public class StartRun implements Runnable{
/**
* 线程入口点
*/
@Override
public void run() {
for(int i=0;i<20;i++) {
System.out.println("一边听歌");
}
}
public static void main(String[] args) {

/* 如果放在这里,那么要先敲完代码再听歌,for循环结束后才启动线程
* for(int i=0;i<20;i++) {
* System.out.println("一边coding");
* }
*/

//创建实现类对象
StartRun sr = new StartRun();
//创建代理类对象
Thread t = new Thread(sr);
//启动
t.start();//不保证立即运行 由cpu调用
//st.run();//普通方法调用,只能听完歌再敲代码
for(int i=0;i<20;i++) {
System.out.println("一边coding");
}
}
}

【运行结果】

1
2
3
4
5
6
7
8
一边coding
一边coding
...
一边听歌
一边听歌
...
一边coding
一边coding
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package liti_07;

/*本例展现这样一种方式:利用Runnable接口直接构造线程并运行
*有如下关键点:
*1、希望该类中创建线程对象,就必须有线程成员,即私有变量t;
*2、在构造函数中构造t引用的线程对象,注意把自己作为参数传给t;
*3、还需要启动线程。由于t长设为私有,故不能直接t.start(),
* 需要设置其他方法,如本例另提供一个公共的start()方法。
**/
public class Ch_7_3 implements Runnable{

public static void main (String[] args) {
System.out.print("Main 开始");
Ch_7_3 m1=new Ch_7_3(1,"奇数线程"); //注意,m1依旧不是线程对象
Ch_7_3 m2=new Ch_7_3(2,"偶数线程");
m1.start(); //注意,调用的是类R自己定义的start()
m2.start();
System.out.print("当前共有"+ Thread.activeCount()+"个线程");
System.out.print("Main 结束");
}

private int d;
private Thread t; //-----新增成员

public void start(){
t.start();
} //-----关键点2

public Ch_7_3(int x, String s){
d=x;
//t=new Thread(this); t.setName(s); //----关键点1
t=new Thread(this,s);
}
public void run(){
for(int i=d; i<50;i=i+2)
System.out.print(" "+i);
//Thread t=Thread.currentThread(); //---此句不再需要
System.out.print(t.getName()+"结束!");
}
}

线程的一些常用方法

1、currentThread()

返回对当前正在执行的线程对象的引用。

2、getId()

返回此线程的标识符

3、getName()

返回此线程的名称

4、getPriority()

返回此线程的优先级

5、isAlive()

测试这个线程是否还处于活动状态。

什么是活动状态呢?

活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备运行的状态。

6、sleep(long millis)

使当前正在执行的线程以指定的毫秒数“休眠”(暂时停止执行),具体取决于系统定时器和调度程序的精度和准确性。

7、interrupt()

中断这个线程。

8、interrupted() 和isInterrupted()

interrupted():测试当前线程是否已经是中断状态,执行后具有将状态标志清除为false的功能

isInterrupted(): 测试线程Thread对相关是否已经是中断状态,但不清楚状态标志

9、 setName(String name)

将此线程的名称更改为等于参数 name 。

10、isDaemon()

测试这个线程是否是守护线程。

11、setDaemon(boolean on)

将此线程标记为 daemon线程或用户线程。

12、join()

在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其他的事务后,需要用到子线程的处理结果,也就是主线程需要等待子线程执行完成之后再结束,这个时候就要用到join()方法了。

join()的作用是:“等待该线程终止”,这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码,只有等到子线程结束了才能执行

13、yield()

yield()方法的作用是放弃当前的CPU资源,将它让给其他的任务去占用CPU时间。注意:放弃的时间不确定,可能一会就会重新获得CPU时间片。

14、setPriority(int newPriority)

更改此线程的优先级

-------------    本文结束  感谢您的阅读    -------------