多线程上
单线程的程序只有一个顺序流;而多线程的程序则可以包括多个顺序执行流,并且多个顺序流之间互不干扰。就像单线程程序如同只雇佣了一个服务员的餐厅,他只有做完一件事情后才可以做下面一件事情;而多线程程序则是雇佣了多名服务员的餐厅,他们可以同时进行着多件事情。
JAVA多线程编程的相关知识:创建、启动线程、控制线程、以及多线程的同步操作。
1.概述:
进程是指正在运行中的程序。每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或叫一个执行单元。
线程是指进程中能够独立执行的控制单元。线程控制着进程的执行。一个进程可以同时运行多个不同的线程。
两者的区别:
一个程序运行后至少有一个进程,一个进程里可以包含一个或多个线程。
每个进程都需要操作系统为其分配独立的内存地址空间,而同一进程中的所有线程在同一块地址空间中工作。这些线程可以共享进程的状态和资源。
2.创建和启动线程:
创建线程有两种方式:
1、继承 java.lang.Thread 类。
2、实现Runnable 接口。
2.1 继承Thread 类创建线程类:
步骤如下 :
1、定义Thread 类的子类,并重写该线程的run() 方法。
2、创建Thread 类的子类的实例,即创建线程对象。
3、调用线程的start方法来启动该线程。
1 //定义Thread 类的子类 2 class ThreadText extends Thread { 3 // 重写run()方法 4 public void run() 5 { 6 for (int a = 0 ; a <10 ; a ++) 7 { 8 System.out.println( currentThread().getName() + ":" + a); 9 } 10 } 11 } 12 public class StratThread { 13 14 public static void main(String args[]) 15 { 16 // 创建Thread 类的子类的实例 17 ThreadText t = new ThreadText() ; 18 // 调用线程的start()方法来启动该线程 19 t.start() ; 20 21 // 主线程调用用户线程的对象run()方法。 22 t.run() ; 23 } 24 }
为什么要重写Thread 类的run() 方法?
Thread 类定义了一个功能,就是用于存储线程要运行的代码,该存储功能就是 run() 方法。即 该run() 方法的方法体就是代表了线程需要完成的任务。所以,我们也把run() 方法称为线程执行体。
为什么要调用 start() 方法来启动线程,而不是run() 方法?
因为调用start() 方法来启动线程,系统会把run() 方法当成线程执行体来处理,而如果直接调用线程对象的run() 方法,则系统会把线程对象当成一个普通的对象,而run() 方法也是一个普通方法,而不是线程执行体。
在上面的代码中第19行和第22行分别调用了start() 和 run() 方法。通过运行的结果如下:
main:0 Thread-0:0 main:1 Thread-0:1 main:2 Thread-0:2 main:3 Thread-0:3 main:4 Thread-0:4 main:5 Thread-0:5 main:6 Thread-0:6 main:7 Thread-0:7 Thread-0:8 Thread-0:9 main:8 main:9
通过运行结果可以看到两个线程交替运行:t 和 main 线程(当运行JAVA程序时,JVM 首先会创建并启动主线程,主线程从main() 开始运行)。所以,当调用 Thread 类的子类调用start() 方法是启动该线程;而调用run() 方法时则只是让主线程运行其run() 方法中的代码,并没有启动新的线程。
注意:局部变量在每一个线程中都是独立的一份。
在上面程序第8行用还用到了Thread 类的两个方法:
> static Thread currentThread () : 该方法是Thread 类的静态方法,该方法返回当前正在执行的线程对象。
> String getName() : 该方法是Thread 的实例方法,该方法返回调用该方法的线程的名字。
2.2 实现Runnable 接口创建线程类:
1、定义 Runnable 接口的实现类,并重写该接口的run方法。
2、创建 Runnable 实现类的实例,并以此实例作为Thread 的target 来创建Thread 对象,该Thread 对象才是真正的线程对象。
3、调用线程对象的 start() 方法来启动该线程。
1 //定义Runnable 接口的实现类 2 class RunnableText implements Runnable 3 { 4 // 重写接口的run方法。 5 public void run() 6 { 7 for (int a = 0 ; a <10 ; a ++) 8 { 9 System.out.println( Thread.currentThread().getName() + ":" + a); 10 } 11 } 12 } 13 14 public class ThreadTextRunnable { 15 16 public static void main(String args[]) 17 { 18 // 创建Runnable 实现类的实例 19 RunnableText t = new RunnableText() ; 20 21 // 通过new Thread(Runnable target ) 创建新线程 22 Thread thread = new Thread(t) ; 23 Thread thread1 = new Thread(t) ; 24 25 // 启动线程。 26 thread.start() ; 27 thread1.start() ; 28 } 29 }
为什么要将Runnable 实现类的实例传递给Thread 的构造函数?
因为,自定的run() 方法所属是 Runnable 接口的实现类的实例。所以,要让线程去指定对象的run() 方法,就必须明确该 run() 方法所属的对象。
2.3 两种方式的区别:
2.3.1 采用实现 Runnable 接口方式的多线程
1、线程类只是实现了 Runnable 接口。所以,还可以继承其他的类。
2、在这种方式下,可以多个线程共享同一个target 对象,所以适合多个相同线程处理同一分资源的情况。
2.3.2 采用继承 Thread 类方式的多线程
1、因为线程继承了 Thread 类,所以不能继承其他父类。
3.线程的运行状态
当线程被创建并启动后,并不是已启动就进入执行状态,也不是一直处于执行状态。在线程的生命周期中要经历如下集中状态:新建、就绪、运行、阻塞、和死亡五种状态。
3.1 新建(New)和就绪(Runnable) 状态:
当程序使用 new 关键字创建一个线程之后,该线程就处于新建状态,这时候它仅仅由JVM为其分配了内存。
当线程对象调用 start() 方法之后,该线程就处于就绪状态。这个状态的线程处于有运行资格,却没有运行权利。如何有运行权利则取决于JVM里线程调度器。
3.2 就绪(Runnable)、运行(Running)和阻塞(Blocked)状态:
如果就绪状态获得了运行权利,则开始执行 run() 方法 的线程执行体,则该线程处于运行状态。
当一条线程开始运行时,他不可能一直处于运行状态(除非它的线程执行体足够短,瞬间就执行结束了)。所以当其他的线程抢到CPU的执行权利时,运行状态则重新进入就绪状态。但是当运行状态的线程发生如下情况时,则会进入阻塞状态(放弃所占用的资源,即没有执行资格):
1、线程调用sleep 方法。当sleep(time) 的时间到了 ,线程又会进入就绪状态。
2、线程试图获得一个同步监视器,但该同步监视器正在被其他线程所持有。
3、线程在等待某个通知(notify、notifyAll),即被wait 挂起。
3.3 线程死亡(Dead)
线程结束后就处于死亡状态:
1、run() 方法执行完成,线程正常结束。
2、线程异常。
3、直接调用该线程的stop() 方法来结束该线程。
注意:不要对处于死亡状态的线程调用 start() 方法,程序只能对新建状态的线程调用 start() 方法。同时对新建状态的线程两次调用start() 方法也是错误的。
4.控制线程
4.1 join 线程
当A 线程执行到了 B 线程的join() 方法时,A 线程就会等待,等 B 线程执行完,A 才会执行。即A 线程 等待B 线程终止。
1 // 定义Runnable 接口的实现类 2 public class JoinText implements Runnable { 3 // 重写run() 方法 4 public void run() 5 { 6 for ( int i = 0; i <= 10 ; ++ i) 7 System.out.println(Thread.currentThread().getName()+ "..." + i); 8 } 9 public static void main(String args[]) throws InterruptedException 10 { 11 // 创建Runnable 接口实现类的实例 12 JoinText t = new JoinText() ; 13 // 通过 Thread(Runnable target) 创建新线程 14 Thread thread = new Thread(t) ; 15 Thread thread1 = new Thread(t) ; 16 // 启动线程 17 thread.start() ; 18 // 只有等thread 线程执行结束,main 线程才会向下执行; 19 thread.join() ; 20 System.out.println("thread1 线程将要启动"); 21 thread1.start() ; 22 } 23 }
在上面程序中,thread 线程调用了join() 方法。所以main 线程会等 thread 线程执行结束才会向下执行,所以运行的结果如下:
Thread-0...0 Thread-0...1 Thread-0...2 Thread-0...3 Thread-0...4 Thread-0...5 Thread-0...6 Thread-0...7 Thread-0...8 Thread-0...9 Thread-0...10 thread1 线程将要启动 Thread-1...0 Thread-1...1 Thread-1...2 Thread-1...3 Thread-1...4 Thread-1...5 Thread-1...6 Thread-1...7 Thread-1...8 Thread-1...9 Thread-1...10
join 的方法有三种重载形式:
void join() : 等待该线程终止。
void join(long millis) : 等待该线程中指的时间最长为 millis 毫秒。
void join(long millis , int nanos) 等待该线程终止的时间最长为 millis
毫秒 + nanos
纳秒。
4.2 守护线程(后台线程)
Daemon Thread ,JVM 的垃圾回收机制就是典型的 后台线程。
调用 Thread 对象 setDaemon(true) 方法可以指定线程设置成后台线程。该方法必须在启动线程钱调用,否则会引发 IllegalThreadStateException 异常。
后台线程特点:如果所有前台线程都死亡,后台线程会自动死亡。
1 public class DaemonText implements Runnable { 2 public void run() 3 { 4 for (int i = 0 ; i < 1000 ; i ++) 5 { 6 System.out.println(Thread.currentThread().getName()+"..."+i); 7 } 8 } 9 public static void main(String args[]) 10 { 11 DaemonText t = new DaemonText() ; 12 Thread thread = new Thread(t) ; 13 14 // 将次线程设置为后台线程 15 thread.setDaemon(true) ; 16 // 启动后台线程 17 thread.start() ; 18 19 for(int i = 0 ; i < 10; i ++) 20 { 21 System.out.println(Thread.currentThread().getName()+"......"+i); 22 } 23 // 程序执行到此,前台线程结束。 24 // 后台线程也随之结束。 25 } 26 }
因为thread 线程被设置成了 后台线程。所以,当主线程运行完后 ,JVM 会主动退出,因而后台线程也被结束。
4.3 线程睡眠:sleep
当当前线程调用 sleep 方法进入阻塞状态后,在其sleep 时间段内,该线程不会获得执行机会,即使系统中没有其他线程了,直到sleep 的时间到了。所以,调用sleep 能让线程暂短暂停。
4.4 线程让步:yield
和sleep 类似,也可以让当前执行的线程暂停,但他不会让线程进入阻塞状态。而是,取消当前线程的执行权,使当前线程进入就绪状态。就是相当于让系统的线程调度器重新调度一次。
4.5 改变线程的优先级
每个线程执行时都具有一定的优先级,优先级高的则获得多的运行机会,优先级低的则获得较少的运行机会。
Thread 提供了 setPriority(int newPriority) 和 getPriority() 方法来设置和返回指定线程的优先级。设置优先级的整数在1~10之间,也可以使用Thread 类的三个静态常量:
> MAX_PRIORITY : 其值是 10
> MIN_PRIORITY : 其值是 1
> NORM_PRIORITY: 其值是 5