Java 线程常用 API【总结】_练习线程类api中的常用静态方法,比如休眠,获取线程名称等,参见api文档。

线程提供了获取相关信息的方法：

1、线程提供了一个静态方法：static Thread currentThread()

该方法用来获取运行这个方法的线程，main方法也是靠一个线程运行的，当JVM启动后会自动创建一个线程来执行main方法，而这个线程的名字叫做"main"，我们称它为主线程。

package thread;

public class ThreadDemo {
	public static void main(String[] args) {
		//获取运行main方法的线程
		Thread main = Thread.currentThread();
		System.out.println("运行main方法的线程："+main);
		
		dosome();
		
		Thread t = new Thread() {
			public void run() {
				Thread t = Thread.currentThread();
				System.out.println("自定义线程：" + t);
				dosome();
			}
		};
		t.start();
	}
	public static void dosome() {
		Thread t = Thread.currentThread();
		System.out.println("运行dosome方法的线程是："+t);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2、线程提供了获取自身信息的相关方法：

package thread;

public class ThreadDemo2 {
	public static void main(String[] args) {
		Thread main = Thread.currentThread();
		//获取线程的名称
		String name = main.getName();
		System.out.println(name);
		
		//获取线程的唯一标识
		long id = main.getId();
		System.out.println(id);
		
		//获取线程的优先级
		int priority = main.getPriority();
		System.out.println("优先级："+priority);
		
		//线程是否还处于活动状态
		boolean isAlive = main.isAlive();
		System.out.println("isAlive："+isAlive);
		
		//线程是否是被中断了
		boolean isInterrupted = main.isInterrupted();
		System.out.println("isInterrupted："+isInterrupted);
		
		//线程是否为守护线程
		boolean isDeamon = main.isDaemon();
		System.out.println("isDeamon："+isDeamon);
	}
}
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

3、线程的优先级：

线程不能主动获取CPU时间片，只能被动的被线程调度分配，调整优先级可以最大程度的改善某个线程获取CPU时间片的次数，理论上线程优先级越高的线程获取CPU时间片的次数越多。

max.setPriority(Thread.MAX_PRIORITY);	//最大优先级
min.setPriority(Thread.MIN_PRIORITY);	//最小优先级
norm.setPriority(Thread.NORM_PRIORITY);	//默认优先级
1
2
3

package thread;

public class PriorityDemo {
	public static void main(String[] args) {
		Thread max = new Thread() {
			public void run() {
				for(int i=0;i<10000;i++) {
					System.out.println("max");
				}
			}
		};
		Thread min = new Thread() {
			public void run() {
				for(int i=0;i<10000;i++) {
					System.out.println("min");
				}
			}
		};
		Thread norm = new Thread() {
			public void run() {
				for(int i=0;i<10000;i++) {
					System.out.println("nor");
				}
			}
		};
		max.setPriority(Thread.MAX_PRIORITY);
		min.setPriority(Thread.MIN_PRIORITY);		
		min.start();
		norm.start();
		max.start();
	}
}
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

4、守护线程：

Java有两种Thread：“守护线程Daemon”与“用户线程User”。

守护线程又称后台线程，默认创建的线程都是普通线程或称为前台线程，线程提供了一个方法setDaemon(boolean on)，只有调用该方法并传入参数为true时，该线程才会被设为守护线程。

守护线程与普通线程的唯一区别是：当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则不会退出。（以上是针对正常退出，调用System.exit则必定会退出）。

所以setDeamon(true)的唯一意义就是告诉JVM不需要等待它退出，让JVM喜欢什么退出就退出吧，不用管它。

守护线程是线程的低级别线程，守护线程在使用上与普通线程没有差别，这个线程具有最低的优先级，用于为系统中的其它对象和线程提供服务，守护线程在没有用户线程可服务时自动离开。

进程的结束：当一个进程中所有普通线程都结束了，进程即结束。

注意：设置为守护线程必须在线程启动前进行设置。

5、线程提供了一个静态方法：static void sleep(long ms)

使用了这个方法的线程阻塞指定毫秒，超时后该线程会自动回到Runnable状态，等待再次并发运行。

sleep方法要求必须处理中断异常，原因在于当一个线程调用了sleep处于阻塞状态过程中被调用了它的interrupt()方法中断时，他就会在sleep方法中抛出中断异常，这时并非真是将这个线程中断，而是中断了它的阻塞状态。

package thread;

public class SleepDemo {
	public static void main(String[] args) {
		System.out.println("程序开始了");
		while(true) {
			System.out.println("你好!");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6、线程提供了一个方法：void join()

thread.join()方法可以协调线程之间的同步运行，它可以把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。

比如在线程B中调用了线程A的Join()方法，直到线程A的run()方法执行完毕后，才会继续执行线程B。

例：下面在show线程中调用download.join()方法后就进入了阻塞状态，直到download线程的run方法执行完毕才会解除阻塞。

package thread;

public class JoinDemo {
	//标识图片是否下载完毕
	private static boolean isFinish = false;
	
	public static void main(String[] args) {
		
		Thread download = new Thread() {
			public void run() {
				System.out.println("down:开始下载图片...");
				for(int i=1;i<=100;i++) {
					System.out.println("down:"+i+"%");
					try {
						Thread.sleep(20);
					} catch (InterruptedException e) {
					}
				}
				System.out.println("down:下载图片完毕!");
				isFinish = true;
			}
		};
		
		Thread show = new Thread() {
			public void run() {
				System.out.println("show:开始显示图片");
				//加载图片前应先等待下载线程将图片下载完毕	
				try {
					/*
					 * show线程在调用download.join()方法后
					 * 就进入了阻塞状态，直到download线程
					 * 的run方法执行完毕才会解除阻塞
					 */
					download.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}				
				if(!isFinish) {
					throw new RuntimeException("加载图片失败!");
				}
				System.out.println("show:显示图片完毕!");
			}
		};
		download.start();
		show.start();
	}
}
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

注意：join和sleep从使用效果上来看，都能使线程处于“阻塞”状态，两者的主要区别是，sleep睡眠期间不会释放对象锁，像一个占有欲很强的小孩，睡觉了还死死地抱着布偶娃娃。join因为内部实现使用了wait方法，当前线程所持有的锁会被释放。