1、进程和线程
进程Process: 每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程。可以把进程简单理解为操作系统中运行的一个程序
线程Thread:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小。
多进程是指操作系统能同时运行多个任务(程序)。多线程是指在同一程序中有多个顺序流在执行。进程是线程的容器,一个进程里可以运行1-N个线程,操作系统以进程为单位分配资源
线程是进程的一个执行分支
2、实现线程的方式
在JAVA中,创建线程就是创建Thread类(子类)的对象(实例)
java.lang.Thread
Thread类的构造方法
Constructor and Description |
Thread() 分配一个新的 Thread对象。 |
分配一个新的 Thread对象。 |
1. 继承Thread类
class ThreadTest extends Thread{
public void run(){
System.out.println("这个线程开始运行");
}
}
public class Test {
public static void main(String[] args) {
ThreadTest tt = new ThreadTest ();
tt.start(); //启动一个线程
}
}
注意:主函数使用start方法启动新线程,而不是调用run方法
2. 实现Runnable接口(优先使用)
class ThreadTest implements Runnable{
public void run(){
System.out.println("这个线程开始运行");
}
}
public class Test {
public static void main(String[] args) {
ThreadTest tt = new ThreadTest ();
Thread t = new Thread(tt);
t.start(); //通过一个线程对象启动它
}
}
这两种方式的区别:
1、继承Thread类:编写简单,可直接操作线程。适用于单继承
2、实现Runnable接口:避免单继承局限性,便于共享资源。
推荐使用实现Runnable接口方式创建线程
3. 实现Callable接口(了解)
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
//创建Callable接口实现类,并实现call()方法,此方法为线程执行体,且有返回值
class CallableThreadTest implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println("执行线程");
return 1;
}
}
public class Test {
public static void main(String[] args) {
//使用FutureTask类(实现了Future和Runnable接口)来包装Callable对象
FutureTask<Integer> ft = new FutureTask<>(new CallableThreadTest());
//使用FutureTask对象作为Thread对象的target创建并启动新线程
new Thread(ft).start();
//调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
try {
System.out.println("子线程的返回值:" + ft.get());
} catch (Exception e) {
e.printStackTrace();
}
}
}
Runnable和Callable的区别:
- Callable规定(重写)的方法是call(),Runnable规定(重写)的方法是run()。
- Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。
- call方法可以抛出异常,run方法不可以。
- 运行Callable任务可以拿到一个Future对象。通过Future对象可以了解任务执行情况,可取消任务的执行,还可获取执行结果。
3、线程生命周期
线程对象的生命周期,也就是线程在五种状态之间的转换。
- [NEW]新建状态
尚未启动的线程处于此状态。新创建了一个线程对象,但未调用start方法 - [RUNNABLE]就绪状态,
即可运行状态,复合状态,包含ready和running两个状态
ready:表示该线程处于可被调度调度的状态
运行状态(Running):就绪状态的线程获取了CPU,执行程序代码。
Thread.yield(): 方法可以将线程由Running状态变为ready 状态
- [BLOCKED]阻塞状态
被阻塞等待监视器锁定的线程处于此状态。
线程发起I/O操作或者申请由其他线程独占的资源,不占用CPU
当阻塞I/O执行完毕可或者获得了申请的资源,状态就变为RUNNABLE
阻塞I/O是指,进程会一直阻塞,直到数据拷贝完成;阻塞I/O模式时最普遍使用的I/O模式,如输入、输出、接受连接等
- [WAITING] 等待状态(无限期的等待)
正在等待另一个线程执行特定动作的线程处于此状态。
线程执行了object.wait() 或thread.join()方法就会把线程转换为等待状态,执行object.notify()方法或者加入的线程执行完毕,线程将重回RUNNABLE状态 - [TIMED_WAITING]等待状态(只等等指定长度的时间)
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
与WAITING的区别是不会无限期的等待,而是等待指定时间后不管期望的操作是否执行完毕,线程都将重回RUNNABLE状态 - [TERMINATED]终止状态
已退出的线程处于此状态。
4、线程运行的不确定性
注意:并不是调用start()方法后,线程就开始运行。而是线程进入就绪状态,等待调度来运行它。所以一个线程的运行是不确定的。
实例:
class ThreadTest extends Thread{
public void run(){
for(int i=0;i<100;i++){
System.out.println(this.getName() + ":" + i);
}
}
}
public class Test{
public static void main(String[] args) {
ThreadTest tt1 = new ThreadTest ();
ThreadTest tt2 = new ThreadTest ();
tt1.start(); //运行结果并不确定!
tt2.start(); //运行结果并不确定!
System.out.println(tt1.isAlive()); //当执行输出语句时,线程是否存活也不确定
System.out.println(tt2.isAlive()); //当执行输出语句时,线程是否存活也不确定
}
}
5、 线程调度常用方法
方法 | 功能 |
getName() setName() | 设置或获取当前线程名称 |
isAlive() | 判断线程是否存活(就绪、运行、阻塞是存活状态) |
getPriority() | 获取线程优先级 |
setPriority() | 设置线程优先级 |
Thread.sleep() | 强迫线程睡眠(单位:毫秒)(不释放同步锁) |
join() | 等待某线程结束,再恢复当前线程的运行 |
yield() | 让出CPU资源,当前线程进入就绪状态 |
wait() | 当前线程进入等待状态,即进入等待池。(释放同步锁,由notify()唤醒) |
notify() notifyAll() | 唤醒等待池中的某个或全部等待线程 |
1. 线程名字
设置线程setName()
获取线程名字getName()
public static void main(String[] args){
RunThread01 r1=new RunThread01();
Thread t1=new Thread(r1);
t1.setName("线程01");
t1.start();
RunThread01 r2=new RunThread01();
Thread t2=new Thread(r2);
t2.setName("线程02");
t2.start();
}
public class RunThread01 implements Runnable {
@Override
public void run() {
for(int i=0;i<=100000;i++){
System.out.println(Thread.currentThread().getName());
}
}
}
2. 判断线程是否存活
ThreadTest t1 = new ThreadTest();
ThreadTest t2 = new ThreadTest();
t1.start();
t2.start();
try {
Thread.sleep(1000); //让主线程睡眠1秒,t1线程肯定死亡。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(t1.isAlive());
3. 线程的优先级
Java线程有优先级,优先级高的线程会获得较多的CPU运行机会。Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。 Java线程的优先级用整数表示,取值范围是1~10; 10最高级。每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY(5)。
ThreadTest t1 = new ThreadTest();
t1.setPriority(1); //设置成最低级
ThreadTest t2 = new ThreadTest();
t2.setPriority(10); //设置成最高级
t1.start();
t2.start();
4. 线程睡眠
Thread.sleep() 强迫线程睡眠(单位:毫秒)
class ThreadTest extends Thread{
public void run(){
for(int i=0;i<10;i++){
System.out.println(i);
try {
Thread.sleep(1000); //每隔一秒后输出
} catch (InterruptedException e) { //线程睡眠期间如果被打断,将抛出异常。
e.printStackTrace();
}
}
}
}
5. 合并线程
join()的功能是:等待某线程结束,再恢复当前线程的运行
或者说:join()把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。
class ThreadTest extends Thread{
public void run(){
for(int i=0;i<10;i++){
System.out.println(this.getName() + ":" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//相当于将tt线程和main线程合并成一个线程。
//那么main线程会等待tt线程结束后再运行。
public static void main(String[] args) {
ThreadTest tt = new ThreadTest ();
tt.start();
try {
tt.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<10;i++){
System.out.println("main:" + i);
}
}
6. 让出CPU资源
yield() 让出CPU资源,当前线程进入就绪状态
class ThreadTest extends Thread{
public void run(){
for(int i=0;i<100;i++){
System.out.println(this.getName() + ":" + i);
if(i%10==0){
Thread.yield();
}
}
}
}
public static void main(String[] args) {
ThreadTest tt1 = new ThreadTest ();
ThreadTest tt2 = new ThreadTest ();
tt1.start();
tt2.start();
}
运行结果:
运行到10时,线程让出CPU资源,进入就绪状态。
注意:
1.yield()是让出资源,但并不放弃。它会进入就绪状态,也就是说:它还会与其他线程
一起抢占资源,所以yield()的线程,仍然有可能再次抢占资源。
2. 在加上线程运行的不确定性,所以会导致上面的结论并不是绝对的,只是出现的
概率要高一些。
7. 线程等待与唤醒(涉及线程同步,在后续生产者消费者部分进行介绍)
wait():当前线程进入等待状态,即进入等待池。(释放同步锁,由notify()唤醒);
notify()/notifyAll():唤醒等待池中的某个或全部等待线程。
通俗的说:
wait()意思是说,我等会儿再用这把锁,CPU也让给你们,我先休息一会儿!notify()意思是说,我用完了,你们谁用?也就是说,wait()会让出对象锁,同时,当前线程休眠,等待被唤醒,如果不被唤醒,就一直阻塞。notify()并不会让当前线程休眠,但会唤醒休眠的线程。
注意:
wait会让出CPU而notify不会,notify重在于通知使用Object的对象“我用完了!”;wait重在通知其它同用一个Object的线程“我暂时不用了”并且让出CPU。
6、 线程的中断
线程的中断
1、自动终断【完成】:一个线程完成执行后(即run方法执行完毕),不能再次运行 。
2、手动中断:
stop( ) —— 已过时,基本不用。(不安全,就像是突然停电)
interrupt( ) ——此方法只是改变中断状态,不会中断一个正在运行的线程。比如:如果当前线程是阻塞状态,那么就结束阻塞状态
3、可通过使用一个标志指示 run 方法退出,从而终止线程(推荐使用)
通常,线程中断的使用场景有以下几个:
- 点击某个桌面应用中的取消按钮时;
- 某个操作超过了一定的执行时间限制需要中止时;
- 多个线程做相同的事情,只要一个线程成功其它线程都可以取消时;
- 一组线程中的一个或多个出现错误导致整组都无法继续时;
- 当一个应用或服务需要停止时。
interrupt( )方法说明:
interrupt()方法只是改变中断状态,不会中断一个正在运行的线程。这一方法实际完成的是,给受阻塞的线程发出一个中断信号,这样受阻线程检查到中断标识,就得以退出阻塞的状态。
更确切的说,如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞,此时调用该线程的interrupt()方法,那么该线程将抛出一个 InterruptedException中断异常(该线程必须事先预备好处理此异常),从而提早地终结被阻塞状态。如果线程没有被阻塞,这时调用 interrupt()将不起作用,直到执行到wait(),sleep(),join()时,才马上会抛出 InterruptedException。
class ThreadTest extends Thread{
@Override
public void run() {
for(int i=0;i<100;i++) {
System.out.println(this.getName()+":"+i);
if(i>10) {
this.interrupt();
}
try {
this.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test05 {
public static void main(String[] args) {
ThreadTest tt1 = new ThreadTest();
tt1.setName("线1");
tt1.start();
ThreadTest tt2 = new ThreadTest();
tt2.setName("线2");
tt2.start();
}
}
上面代码中,一旦i>10,那么就会中断sleep状态。