进程与线程
进程是程序的一次动态执行过程,它需要经历从代码加载,代码执行到执行完毕的一个完整的过程,这个过程也是进程本身从产生,发展到最终消亡的过程。多进程操作系统能同时达运行多个进程(程序),由于 CPU 具备分时机制,所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快,使得所有程序好像是在同时运行一样。
多线程是实现并发机制的一种有效手段。进程和线程一样,都是实现并发的一个基本单位。线程是比进程更小的执行单位,线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程在执行过程中可以产生多个更小的程序单元,这些更小的单元称为线程,这些线程可以同时存在,同时运行,一个进程可能包含多个同时执行的线程。进程与线程的区别如图所示:
Java中线程实现的方式
在 Java 中实现多线程有两种手段,一种是继承 Thread 类,另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用。
实现 Runnable 接口
1 package ljz;
2 class MyThread implements Runnable {
3 private String name ;
4 public MyThread ( String name) {
5 this . name = name ;
6 }
7 public void run ( ) {
8 for ( int i= 0 ; i< 10 ; i++ ) {
9 System. out. println ( name + "运行,i = " + i) ;
10 }
11 }
12 } ;
13 public class RunnableDemo01 {
14 public static void main ( String args[ ] ) {
15 MyThread mt1 = new MyThread ( "线程A " ) ;
16 MyThread mt2 = new MyThread ( "线程B " ) ;
17 Thread t1 = new Thread ( mt1) ;
18 Thread t2 = new Thread ( mt2) ;
19 t1. start ( ) ;
20 t2. start ( ) ;
21 }
22 } ;
程序运行结果:
继承 Thread 类
1 class MyThread extends Thread {
2 private String name ;
3 public MyThread ( String name) {
4 this . name = name ;
5 }
6 public void run ( ) {
7 for ( int i= 0 ; i< 10 ; i++ ) {
8 System. out. println ( name + "运行,i = " + i) ;
9 }
10 }
11 } ;
12 public class ThreadDemo02 {
13 public static void main ( String args[ ] ) {
14 MyThread mt1 = new MyThread ( "线程A " ) ;
15 MyThread mt2 = new MyThread ( "线程B " ) ;
16 mt1. start ( ) ;
17 mt2. start ( ) ;
18 }
19 } ;
程序运行结果:
从程序可以看出,现在的两个线程对象是交错运行的,哪个线程对象抢到了 CPU 资源,哪个线程就可以运行,所以程序每次的运行结果肯定是不一样的,在线程启动虽然调用的是 start() 方法,但实际上调用的却是 run() 方法定义的主体。
Thread 类和 Runnable 接口
通过 Thread 类和 Runable 接口都可以实现多线程,那么两者有哪些联系和区别呢?下面我们观察 Thread 类的定义。
public class Thread extends Object implements Runnable
从 Thread 类的定义可以清楚的发现,Thread 类也是 Runnable 接口的子类,但在Thread类中并没有完全实现 Runnable 接口中的 run() 方法,下面是 Thread 类的部分定义。
1 Private Runnable target;
2 public Thread ( Runnable target, String name) {
3 init ( null, target, name, 0 ) ;
4 }
5 private void init ( ThreadGroup g, Runnable target, String name, long stackSize) {
6 . . .
7 this . target= target;
8 }
9 public void run ( ) {
10 if ( target!= null) {
11 target. run ( ) ;
12 }
13 }
从定义中可以发现,在 Thread 类中的 run() 方法调用的是 Runnable 接口中的 run() 方法,也就是说此方法是由 Runnable 子类完成的,所以如果要通过继承 Thread 类实现多线程,则必须覆写 run()。
实际上 Thread 类和 Runnable 接口之间在使用上也是有区别的,如果一个类继承 Thread类,则不适合于多个线程共享资源,而实现了 Runnable 接口,就可以方便的实现资源的共享。
线程的状态变化
要想实现多线程,必须在主线程中创建新的线程对象。任何线程一般具有5种状态,即创建,就绪,运行,阻塞,终止。下面分别介绍一下这几种状态:
在程序中用构造方法创建了一个线程对象后,新的线程对象便处于新建状态,此时它已经有了相应的内存空间和其他资源,但还处于不可运行状态。新建一个线程对象可采用Thread 类的构造方法来实现,例如 “Thread thread=new Thread()”。
新建线程对象后,调用该线程的 start() 方法就可以启动线程。当线程启动时,线程进入就绪状态。此时,线程将进入线程队列排队,等待 CPU 服务,这表明它已经具备了运行条件。
当就绪状态被调用并获得处理器资源时,线程就进入了运行状态。此时,自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。
一个正在执行的线程在某些特殊情况下,如被人为挂起或需要执行耗时的输入/输出操作,会让 CPU 暂时中止自己的执行,进入阻塞状态。在可执行状态下,如果调用sleep(),suspend(),wait() 等方法,线程都将进入阻塞状态,发生阻塞时线程不能进入排队队列,只有当引起阻塞的原因被消除后,线程才可以转入就绪状态。
线程调用 stop() 方法时或 run() 方法执行结束后,即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。
在此提出一个问题,Java 程序每次运行至少启动几个线程?
回答:至少启动两个线程,每当使用 Java 命令执行一个类时,实际上都会启动一个 JVM,每一个JVM实际上就是在操作系统中启动一个线程,Java 本身具备了垃圾的收集机制。所以在 Java 运行时至少会启动两个线程,一个是 main 线程,另外一个是垃圾收集线程。
取得和设置线程的名称
1 class MyThread implements Runnable {
2 public void run ( ) {
3 for ( int i= 0 ; i< 3 ; i++ ) {
4 System. Out. Println ( Thread. currentThread ( ) . getName ( ) + "运行, i=" + i) ;
5 }
6 }
7 } ;
8
9 public class ThreadDemo {
10 public static void main ( String args[ ] ) {
11 MyThread my= new MyThread ( ) ;
12 new Thread ( my) . start;
13 new Thread ( my, "线程A" ) . start ( ) ;
14 }
15 } ;
程序运行结果:
线程的操作方法
刚才在分析自定义模式工作原理的时候其实就已经提到了,如果想要更改Glide的默认配
线程的强制运行
在线程操作中,可以使用 join() 方法让一个线程强制运行,线程强制运行期间,其他线程无法运行,必须等待此线程完成之后才可以继续执行。
1 class MyThread implements Runnable {
2 public void run ( ) {
3 for ( int i= 0 ; i< 50 ; i++ ) {
4 System. out. println ( Thread. currentThread ( ) . getName ( )
5 + "运行,i = " + i) ;
6 }
7 }
8 } ;
9 public class ThreadJoinDemo {
10 public static void main ( String args[ ] ) {
11 MyThread mt = new MyThread ( ) ;
12 Thread t = new Thread ( mt, "线程" ) ;
13 t. start ( ) ;
14 for ( int i= 0 ; i< 50 ; i++ ) {
15 if ( i> 10 ) {
16 try {
17 t. join ( ) ;
18 } catch ( InterruptedException e) {
19 }
20 }
21 System. out. println ( "Main线程运行 --> " + i) ;
22 }
23 }
24 } ;
程序运行结果:
线程的休眠
在程序中允许一个线程进行暂时的休眠,直接使用 Thread.sleep() 即可实现休眠。
1 class MyThread implements Runnable {
2 public void run ( ) {
3 for ( int i= 0 ; i< 50 ; i++ ) {
4 try {
5 Thread. sleep ( 500 ) ;
6 } catch ( InterruptedException e) {
7 }
8 System. out. println ( Thread. currentThread ( ) . getName ( )
9 + "运行,i = " + i) ;
10 }
11 }
12 } ;
13 public class ThreadSleepDemo {
14 public static void main ( String args[ ] ) {
15 MyThread mt = new MyThread ( ) ;
16 Thread t = new Thread ( mt, "线程" ) ;
17 t. start ( ) ;
18 }
19 } ;
程序执行结果:
中断线程
当一个线程运行时,另外一个线程可以直接通过interrupt()方法中断其运行状态。
1 class MyThread implements Runnable {
2 public void run ( ) {
3 System. out. println ( "1、进入run()方法" ) ;
4 try {
5 Thread. sleep ( 10000 ) ;
6 System. out. println ( "2、已经完成了休眠" ) ;
7 } catch ( InterruptedException e) {
8 System. out. println ( "3、休眠被终止" ) ;
9 return ;
10 }
11 System. out. println ( "4、run()方法正常结束" ) ;
12 }
13 } ;
14 public class ThreadInterruptDemo {
15 public static void main ( String args[ ] ) {
16 MyThread mt = new MyThread ( ) ;
17 Thread t = new Thread ( mt, "线程" ) ;
18 t. start ( ) ;
19 try {
20 Thread. sleep ( 2000 ) ;
21 } catch ( InterruptedException e) {
22 System. out. println ( "3、休眠被终止" ) ;
23 }
24 t. interrupt ( ) ;
25 }
26 } ;
程序运行结果是:
后台线程
在 Java 程序中,只要前台有一个线程在运行,则整个 Java 进程都不会消失,所以此时可以设置一个后台线程,这样即使 Java 线程结束了,此后台线程依然会继续执行,要想实现这样的操作,直接使用 setDaemon() 方法即可。
1 class MyThread implements Runnable {
2 public void run ( ) {
3 while ( true ) {
4 System. out. println ( Thread. currentThread ( ) . getName ( ) + "在运行。" ) ;
5 }
6 }
7 } ;
8 public class ThreadDaemonDemo {
9 public static void main ( String args[ ] ) {
10 MyThread mt = new MyThread ( ) ;
11 Thread t = new Thread ( mt, "线程" ) ;
12 t. setDaemon ( true ) ;
13 t. start ( ) ;
14 }
15 } ;
在线程类 MyThread 中,尽管 run() 方法中是死循环的方式,但是程序依然可以执行完,因为方法中死循环的线程操作已经设置成后台运行。
线程的优先级
在 Java 的线程操作中,所有的线程在运行前都会保持在就绪状态,那么此时,哪个线程的优先级高,哪个线程就有可能会先被执行。
1 class MyThread implements Runnable {
2 public void run ( ) {
3 for ( int i= 0 ; i< 5 ; i++ ) {
4 try {
5 Thread. sleep ( 500 ) ;
6 } catch ( InterruptedException e) {
7 }
8 System. out. println ( Thread. currentThread ( ) . getName ( )
9 + "运行,i = " + i) ;
10 }
11 }
12 } ;
13 public class ThreadPriorityDemo {
14 public static void main ( String args[ ] ) {
15 Thread t1 = new Thread ( new MyThread ( ) , "线程A" ) ;
16 Thread t2 = new Thread ( new MyThread ( ) , "线程B" ) ;
17 Thread t3 = new Thread ( new MyThread ( ) , "线程C" ) ;
18 t1. setPriority ( Thread. MIN_PRIORITY) ;
19 t2. setPriority ( Thread. MAX_PRIORITY) ;
20 t3. setPriority ( Thread. NORM_PRIORITY) ;
21 t1. start ( ) ;
22 t2. start ( ) ;
23 t3. start ( ) ;
24 }
25 } ;
程序运行结果:
从程序的运行结果中可以观察到,线程将根据其优先级的大小来决定哪个线程会先运行,但是需要注意并非优先级越高就一定会先执行,哪个线程先执行将由 CPU 的调度决定。
线程的礼让
在线程操作中,也可以使用 yield() 方法将一个线程的操作暂时让给其他线程执行
1 class MyThread implements Runnable {
2 public void run ( ) {
3 for ( int i= 0 ; i< 5 ; i++ ) {
4 try {
5 Thread. sleep ( 500 ) ;
6 } catch ( Exception e) {
7 }
8 System. out. println ( Thread. currentThread ( ) . getName ( )
9 + "运行,i = " + i) ;
10 if ( i== 2 ) {
11 System. out. print ( "线程礼让:" ) ;
12 Thread. currentThread ( ) . yield ( ) ;
13 }
14 }
15 }
16 } ;
17 public class ThreadYieldDemo {
18 public static void main ( String args[ ] ) {
19 MyThread my = new MyThread ( ) ;
20 Thread t1 = new Thread ( my, "线程A" ) ;
21 Thread t2 = new Thread ( my, "线程B" ) ;
22 t1. start ( ) ;
23 t2. start ( ) ;
24 }
25 } ;
程序执行结果: