tonglin0325的个人主页

Java线程操作方法

tonglin0325

 

取得和设置线程名称

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
43
44
45
46
//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;
	
//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
//			System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}
	
}



//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		
		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		new Thread(mt1).start();								//系统自动设置线程名称
		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
		new Thread(mt1).start();								//系统自动设置线程名称
		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

手工设置线程名称　　　　系统自动设置线程名称

　　　　　　　　

 

判断线程是否启动

使用isAlive()方法来判断线程是否已经启动而且仍然在启动

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
43
44
45
46
47
48
49
//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;
	
	public MyThread_1(String name) {	//构造方法
		super();
		this.name = name;
	}
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
//			System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}
	
}



//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1("线程A ");	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1("线程B ");	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1);							//实例化Thread类对象
		Thread t2 = new Thread(mt2);							//实例化Thread类对象
		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.start();																	//启动线程
		System.out.println("线程开始执行之后-->"+t1.isAlive());
		t2.start();																	//启动线程

	}

}

 主线程有可能比其他线程先执行完

 

线程的强制运行

在线程操作中，可以使用join()方法让一个线程强制运行，线程强制运行期间，期间线程无法运行，必须等待此线程完成之后才可以继续执行。

 

线程的休眠

在程序中允许一个线程进行暂时的休眠，直接使用Thread.sleep()方法即可实现休眠

程序在执行的时候，每次的输出都会间隔500ms，达到了延时操作的效果。

Thread.sleep()方法要用try和catch语句包围

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
//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：Mythread
// 属性：
// 方法：
class Mythread implements Runnable{	//实现Runnable接口
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<5;i++){
			try{
				Thread.sleep(500);						//线程休眠
			}catch (Exception e){}				//需要异常处理
				System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}
	
}

//主类
//Function        : 	ThreadSleep_demo
public class ThreadSleep_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Mythread m = new Mythread();
		new Thread(m,"线程").start();
	}

}

 

中断线程

当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。

一个线程启动之后进入了休眠状态，原来是要休眠10s之后再继续执行，但是主方法在线程启动之后的2s之后就将其中断，休眠一旦中断之后将执行catch中的代码。

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
43
44
//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：Mythread_1
// 属性：
// 方法：
class Mythread_1 implements Runnable{	//实现Runnable接口
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		System.out.println("进入run方法");
		try{
			Thread.sleep(10000);						//线程休眠
			System.out.println("休眠完成");
				}catch (Exception e){				//需要异常处理
			System.out.println("休眠被终止");
			return;												//让程序返回被调用处
		}
		System.out.println("run方法结束");
	}
	
}

//主类
//Function        : 	ThreadSleep_demo
public class ThreadInterrupt_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Mythread_1 m = new Mythread_1();
		Thread t = new Thread(m,"线程");
		t.start();
		try{
			Thread.sleep(2000);			//主线程2s之后再执行中断
		}catch(Exception e){}
		t.interrupt();
	}

}

 

后台线程

在Java程序中，只要前台有一个线程在运行，则整个Java进程都不会消失，所以此时可以设置一个后台线程，这样即使Java进程结束了，此后台线程依然会继续执行。要想实现这样的操作，直接使用setDaemon()方法即可。

 

线程的优先级

在Java的线程中使用setPriority()方法可以设置一个线程的优先级，在Java的线程中一共有3种优先级。

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;
	
//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
			//System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
		}
	}
	
}



//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt3 = new MyThread_1();	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1,"线程A");							//实例化Thread类对象
		Thread t2 = new Thread(mt2,"线程B");							//实例化Thread类对象
		Thread t3 = new Thread(mt3,"线程C");							//实例化Thread类对象
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		t1.start();																	//启动线程
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t2.start();																	//启动线程
		t3.start();																	//启动线程
		
//		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
//		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

 线程将根据优先级的大小来决定哪个线程会先运行，但是并非线程的优先级越高就一定会先执行，哪个线程先执行将由CPU的调度决定。

主方法的优先级是NORM，通过Thread.currentThread().getPriority()来取得主方法的优先级，结果是5

 

线程的礼让

在线程的操作中，可以使用yield()方法将一个线程的操作暂时让给其他线程执行。本线程暂停，让其他进程先执行。

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
//=================================================
// File Name       :	Thread_demo
//------------------------------------------------------------------------------
// Author          :	Common


// 接口名：MyThread
// 属性：
// 方法：
class MyThread_1 implements Runnable{	//实现Runnable接口
	private String name;
	
//	public MyThread_1(String name) {	//构造方法
//		super();
//		this.name = name;
//	}
	
	@Override
	public void run() {								//覆写Thread类中的run()方法
		// TODO 自动生成的方法存根
		for (int i=0;i<10;i++){
			//System.out.println(name+"运行，i="+i);
			System.out.println(Thread.currentThread().getName()+",i="+i);	//取出当前线程的名称
			if(i==3){
				System.out.println("线程礼让：");
				Thread.currentThread().yield();	//线程礼让
			}
		}
	}
	
}



//主类
//Function        : 	Thread_demo
public class Runnable_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt2 = new MyThread_1();	//实例化Runnable子类对象
		MyThread_1 mt3 = new MyThread_1();	//实例化Runnable子类对象
		Thread t1 = new Thread(mt1,"线程A");							//实例化Thread类对象
		Thread t2 = new Thread(mt2,"线程B");							//实例化Thread类对象
		Thread t3 = new Thread(mt3,"线程C");							//实例化Thread类对象
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		t1.start();																	//启动线程
//		System.out.println("线程开始执行之前-->"+t1.isAlive());
		t2.start();																	//启动线程
		t3.start();																	//启动线程
		
//		MyThread_1 mt1 = new MyThread_1();	//实例化Runnable子类对象
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1,"线程A").start();				//手工自动设置线程名称
//		new Thread(mt1,"线程B").start();				//手工自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
//		new Thread(mt1).start();								//系统自动设置线程名称
	}

}

 　　　　线程礼让也是不一定的

tonglin0325

标签

标签云

AWS Airbnb Android CDH Doris ELK Flink Git Grafana HAProxy HBase Hadoop Hive Hudi InfluxDB JDBC JMeter JVM Java JavaWeb LaTex Linkedin Linux ML ML Infra MPP Maven MySQL Nexus OpenTSDB Paper Play Prometheus Python React Redis RocksDB Scala Solr Spark SpringBoot SpringMVC Thrift YARN antlr arthas avro cassandra clickhouse confluent docker filebeat flume golang google gradle hexo impala jenkins k8s kafka kerberos kudu ldap mac mongo mybatis nginx nlp open-falcon openwrt parquet presto ranger scyllaDB twitter zookeeper 刷题 前端 图存储及计算 多线程 广告系统 开发工具 数据结构 杂谈 正则表达式 算法 系统设计 计算机网络 设计模式

文章归档

最近文章