Java多线程（一）

忧郁的西红柿

已于 2024-08-31 09:21:38 修改

阅读量404

点赞数 20

文章标签： linux 服务器运维

于 2024-08-30 19:21:50 首次发布

本文链接：https://blog.csdn.net/My_story_begins/article/details/141725300

版权

1、进程和线程

进程Process：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。可以把进程简单理解为操作系统中运行的一个程序

线程Thread：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。

多进程是指操作系统能同时运行多个任务（程序）。多线程是指在同一程序中有多个顺序流在执行。进程是线程的容器，一个进程里可以运行1-N个线程，操作系统以进程为单位分配资源

线程是进程的一个执行分支

2、实现线程的方式

在JAVA中，创建线程就是创建Thread类（子类）的对象（实例）

java.lang.Thread

public class Thread extends Object implements Runnable

Thread类的构造方法

Constructor and Description

Thread()

分配一个新的 Thread对象。

Thread(Runnable target)

分配一个新的 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状态。

忧郁的西红柿

关注

20
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Java多线程（一）

wait()：当前线程进入等待状态，即进入等待池。（释放同步锁，由notify()唤醒）；notify()/notifyAll()：唤醒等待池中的某个或全部等待线程。通俗的说：wait()意思是说，我等会儿再用这把锁，CPU也让给你们，我先休息一会儿！notify()意思是说，我用完了，你们谁用？也就是说，wait()会让出对象锁，同时，当前线程休眠，等待被唤醒，如果不被唤醒，就一直阻塞。notify()并不会让当前线程休眠，但会唤醒休眠的线程。
复制链接

扫一扫