java 多线程函数_Java多线程（三）关于多线程管理的相关函数说明

最新推荐文章于 2022-12-31 12:30:09 发布

6路

最新推荐文章于 2022-12-31 12:30:09 发布

阅读量161

点赞数

文章标签： java 多线程函数

本文链接：https://blog.csdn.net/weixin_36296983/article/details/114064290

版权

接着前面的多线程(二)的内容，下面我们接着来探讨多个线程创建之后，关于线程调度和管理的一些方法。

先来简单介绍下线程调度###

对于计算机的CPU(以单核为例)，在任意时刻只能执行一条指令，每个线程只有获得CPU的使用权才能执行指令。当有多个处于可运行状态的线程在等待CPU，JVM的一项任务就是负责线程的调度。JVM按照特定机制为多个线程分配CPU的使用权过程就是线程调度。

线程调度的两种模型：分时调度模型和抢占式调度模型。

① 分时调度模型是指让所有的线程轮流获得cpu的使用权,并且平均分配每个线程占用的CPU的时间片，这个比较好理解。

② JVM采用抢占式调度模型，就是让线程抢夺CPU资源，运行顺序是不确定的，优先权高的线程，会有一定几率优先占用CPU。处于运行状态的线程会一直运行下去，直至它不得不放弃CPU。比如线程运行完毕、线程阻塞、运行被打断。关于线程的多种运行状态详见：Java中的多线程(二)线程的创建及线程的生命周期。当线程被中断时，CPU会保存当前线程的状态，以备此线程被唤醒时继续执行。

线程管理之设置线程优先级###

Java线程优先级共有10个级别，优先级较高的线程会获得较多的运行机会，取值范围是从1到10。如果小于1或大于10，则JDK抛出异常IllegalArgumentException()。Thread类有以下三个静态常量：

① static final int MAX_PRIORITY ：值为10，代表最高优先级。

② static final int MIN_PRIORITY ：值为1，代表最低优先级。

③ static final int NORM_PRIORITY：值为5，代表默认优先级。

这里要注意的是：

① 并不是说优先级较高的线程一定会在优先级较低的线程之前运行，优先级高这里是指获得较多的运行机会。

② 优先级高的线程会大部分先执行完，并不一定会全部执行完毕。

③ 子线程的优先级是跟父类优先级是一样的。

设置和获取优先级方法：

thread.setPriority(Thread.MIN_PRIORITY)和 thread.getPriority()

线程管理之守护线程###

我们在程序中创建的线程默认都是用户线程(User Thread)。与用户线程对应则是守护线程(Daemon Thread)，也可称之为后台线程，它的作用就是为其它线程提供服务的。守护线程使用的情况较少，举例来说：JVM的垃圾(GC)回收线程就是守护线程。

需要注意的是：

① 当所有的用户线程都结束退出的时候，守护线程也就没啥可服务的了，随着线程的结束而结束。如果JVM只剩下守护线程，虚拟机就会退出。

② 守护线程会随时中断，因此不要在如输入输出流，数据库连接等场合使用守护线程。

③ 守护线程并非是JVM内部可提供，我们自己可以根据需要来设定守护线程。可以通过isDaemon和setDaemon方法来判断和设置一个线程为守护线程。

④ 守护线程必须在start方法前设置，否则会抛出IllegalThreadStateException异常。

⑤ 一个守护线程创建的子线程依然是守护线程。

package com.Dan;

public class Main {

public static void main(String[] args) {

// write your code here

DaemonThread daemonThread = new DaemonThread();

// 设置为守护线程

daemonThread.setDaemon(true);

daemonThread.start();

}

class DaemonThread extends Thread {

public void run() {

System.out.println(Thread.currentThread().getName() + " start");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " end");

}

// Thread-0 start

// 子线程需要执行1秒，因为设置被设置为守护线程，因此主线程不会等待子线程执行结束，而是提前退出。

// 所有用户线程都退出了，守护线程也就退出了，因此并没有打印end。

线程管理之常用方法###

一些简单方法#####

public static int activeCount()：返回当前线程的线程组中活动线程的数目。

public static Thread currentThread()：返回对当前正在执行的线程对象的引用。

public long getId()：返回该线程的标识符，线程 ID 是唯一的。

public final void setName(String name)：改变线程名称。

public final String getName()：返回该线程的名称。

public String toString()：返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

public void start()：使该线程开始执行，Java 虚拟机调用该线程的 run 方法。

下面是一些比较重要的方法：

sleep()方法线程睡眠#####

sleep方法作用就是让当前线程休眠，交出CPU，让CPU去执行其他的任务。当前线程是指this.currentThread()返回的线程。sleep方法使线程转到阻塞状态，当睡眠结束后，就转为可运行状态。

package com.Dan;

/**

* Created by daniel on 17/3/27.

public class 多线程博客三 {

public static void main(String[] args) {

System.out.println(Thread.currentThread().getName()+"主线程开始执行。");

TaskThread thread1 = new TaskThread("线程-A-");

TaskThread thread2 = new TaskThread("线程-B-");

thread1.start();

thread2.start();

System.out.println(Thread.currentThread().getName()+ "主线程运行结束。");

}

class TaskThread extends Thread{

private String name;

public TaskThread(String name) {

this.name = name;

}

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + "子线程运行开始。");

for (int i = 0; i < 5; i++) {

System.out.println(name + "运行: " + i);

try {

sleep((long) Math.random() * 100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "子线程运行结束!");

}

// main主线程开始执行。

// Thread-0子线程运行开始。

// Thread-1子线程运行开始。

// 线程-B-运行: 0

// main主线程运行结束。

// 线程-A-运行: 0

// 线程-B-运行: 1

// 线程-A-运行: 1

// 线程-B-运行: 2

// 线程-A-运行: 2

// 线程-B-运行: 3

// 线程-A-运行: 3

// 线程-B-运行: 4

// 线程-A-运行: 4

// Thread-1子线程运行结束。

// Thread-0子线程运行结束。

// sleep方法使当前线程休眠，交出CPU，让CPU去执行其他的任务。这里的主线程，早在子线程开始后就马上结束了。

join()线程加入#####

在当前线程中调用另一个线程的join方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为可运行状态。如果调用此方法时，另一个线程已经运行完毕，那就接着运行当前线程。

package com.Dan;

/**

* Created by daniel on 17/3/27.

public class ThreadJoin {

public static void main(String[] args) {

Thread thread = new Thread(new Runnable() { //匿名对象

@Override

public void run() {

for (int i = 0; i < 10; i++) {

System.out.println(Thread.currentThread().getName() + " 子线程 " + i);

}

});

thread.start();

for (int i = 0; i < 10; i++) {

if (i == 5) {

try {

thread.join(); // 此时调用Thread线程

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " 主线程 " + i);

}

// main 主线程 0

// main 主线程 1

// main 主线程 2

// main 主线程 3

// main 主线程 4

// 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

// main 主线程 5

// main 主线程 6

// main 主线程 7

// main 主线程 8

// main 主线程 9

yield()线程让步#####

暂停当前正在运行的线程，把运行机会让给其它的线程。这里的暂停，并不是让线程转到阻塞或等待状态，而是返回可运行状态，等待被调度运行。需要注意的是，此时让步的线程是可运行状态，它有可能会被再次运行。

package com.Dan;

/**

* Created by daniel on 17/3/24.

public class JavaEveryDay0324 extends Thread{

public static void main(String[] args) {

JavaEveryDay0324 test1 = new JavaEveryDay0324();

JavaEveryDay0324 test2 = new JavaEveryDay0324();

test1.start();

test2.start();

}

@Override

public void run() {

System.out.println(Thread.currentThread().getName() + " 1");

yield();

System.out.println(Thread.currentThread().getName() + " 2");

}

// Thread-0 1

// Thread-1 1

// Thread-0 2

// Thread-1 2

// 线程test1在输出1后，执行yield()方法进入可运行状态，然后将CPU让给线程test2。同样线程test2运行输出1后，执行yield()方法也进入了可运行状态，将CPU又让给线程test1，线程test1继续执行，打印输出2，然后线程test2执行输出2。

// Thread-0 1

// Thread-0 2

// Thread-1 1

// Thread-1 2

// 也有可能出现这种情况，多运行几次，肯定会有的。

// Thread-0 1

// Thread-1 1

// Thread-1 2

// Thread-0 2

// 又或者是这一种。只要记住它返回的是可运行状态，不是阻塞，也不是等待。那么不同的结果就能解释清楚了。

** interrupt()线程中断信号**#####

interrupt():这里只谈中断信号，中断线程后续博客会更新。它向线程发送一个中断信号，强制结束调用该方法的线程当前状态，让线程在无限等待时(如死锁时)能抛出异常。

package com.Dan;

/**

* Created by daniel on 17/3/27.

public class ThreadInterrupt {

public static void main(String[] args) {

Thread thread = new Thread(new Runnable() {

@Override

public void run() {

try {

Thread.sleep(5000000); // 别想醒过来了

} catch (InterruptedException e) {

//e.printStackTrace();

System.out.println("抛异常喽吆唉哈咦。");

}

for (int i = 0; i < 10; i++) {

System.out.println(Thread.currentThread().getName() + " 子线程 " + i);

}

});

thread.start();

for (int i = 0; i < 6; i++) {

if (i == 2) {

thread.interrupt(); // 终止当前线程的状态，并抛出个异常: e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "输出：" + i);

}

// main输出：0

// main输出：1

// 抛异常喽吆唉哈咦。

// main输出：2

// Thread-0 子线程 0

// Thread-0 子线程 1

// Thread-0 子线程 2

// Thread-0 子线程 3

// Thread-0 子线程 4

// Thread-0 子线程 5

// main输出：3

// main输出：4

// Thread-0 子线程 6

// Thread-0 子线程 7

// Thread-0 子线程 8

// Thread-0 子线程 9

// main输出：5

** wait()线程等待**#####

这里先简单介绍下wait方法，我们会在下一篇博客探讨线程同步相关知识的时候，再来探讨它。

在线程通信中，wait方法经常与notify和notifyAll方法一起使用。，他们并不是Thread类的方法，而是Object类的方法。

① wait：当达到某种状态的时候，wait方法让线程进入等待状态，让本线程休眠。线程自动释放其占有的对象锁，并等待notify。直到有其它线程调用对象的notify方法唤醒该线程，才能继续获取对象锁，继续运行。

② notify：唤醒一个正在等待当前对象锁的线程，并让它拿到对象锁。

③ notifyAll：唤醒所有正在等待前对象锁的线程。

需要注意的是：

① 在调用这3个方法的时候，当前线程必须获得这个对象的锁，也就是说这三个方法必须在synchronized(Obj){...}内部。

② 在调用notify方法后，并不会马上释放对象锁，而是在synchronized(){}执行结束的时候，自动释放锁，JVM会随机唤醒一个正在等待当前对象锁的线程，让他获得对象锁，唤醒线程。

** wait()与sleep()方法的区别**#####

① sleep方法是一个静态方法，作用在当前线程上。而wait方法是一个实例方法，并且只能在其他线程调用本实例的notify方法时被唤醒。

② wait只能在线程同步环境中被调用，会释放锁。而sleep不限制使用环境，当在一个Synchronized块中调用Sleep方法时，线程虽然休眠了，但是对象的锁并木有被释放，其他线程无法访问这个对象。

③ sleep必须捕获异常，而wait，notify和notifyAll则不需要。

④ 进入等待状态的线程能够被notify方法唤醒。sleep休眠时间到了，该线程不一定会立即执行，因为其它线程可能正在运行。

⑤ 如果你需要暂停某个线程一段特定的时间，就使用sleep方法。如果你想要实现线程间通信就使用wait方法。

** 关于 “调用yield()方法后，会选择同等优先级的线程继续执行。” 勘误**#####

看到网上有人说调用yield()方法后，会选择同等优先级或更高优先级的线程继续执行。这个观点是错误的。具体执行执行哪个线程是由JVM说了算。请看下面的例子，低优先级的也会被执行。

// 在上面方法基础上重新修改的

package com.Dan;

/**

* Created by daniel on 17/3/24.

public class JavaEveryDay0324 extends Thread{

public static void main(String[] args) {

JavaEveryDay0324 test3 = new JavaEveryDay0324();

JavaEveryDay0324 test1 = new JavaEveryDay0324();

JavaEveryDay0324 test2 = new JavaEveryDay0324();

test3.setPriority(1);

test2.setPriority(10);

test1.setPriority(5);

test3.start();

test1.start();

test2.start();

System.out.println("线程1ID: "+test1.getId()+" 线程2ID: "+test2.getId()+" 线程3ID: "+test3.getId());

}

@Override

public void run() {

for (int i = 0; i < 3; i++) {

System.out.println("线程ID为"+Thread.currentThread().getId()+"： " + " 的第①次打印");

yield();

System.out.println("线程ID为"+Thread.currentThread().getId() +"： " + " 的第②次打印");

}

// 线程ID为10：的第①次打印

// 线程ID为11：的第①次打印

// 线程ID为12：的第①次打印

// 线程1ID: 11 线程2ID: 12 线程3ID: 10

// 线程ID为10：的第②次打印

// 线程ID为10：的第①次打印

// 线程ID为11：的第②次打印

// 线程ID为11：的第①次打印

// 线程ID为12：的第②次打印

// 线程ID为12：的第①次打印

// 线程ID为10：的第②次打印

// 线程ID为10：的第①次打印

// 线程ID为11：的第②次打印

// 线程ID为11：的第①次打印

// 线程ID为12：的第②次打印

// 线程ID为12：的第①次打印

// 线程ID为10：的第②次打印

// 线程ID为12：的第②次打印

// 线程ID为11：的第②次打印

写完喽！ㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏㄟ(▔,▔)ㄏ

知识重在总结和梳理，只有不断地去学习并运用，才能化为自己的东西。当你能为别人讲明白的时候，说明自己已经掌握了。

欢迎转载，转载请注明出处！

如果有错误的地方，或者有您的见解，还请不啬赐教！

喜欢的话，麻烦点个赞！

6路

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java 多线程函数_Java多线程（三）关于多线程管理的相关函数说明

接着前面的多线程(二)的内容，下面我们接着来探讨多个线程创建之后，关于线程调度和管理的一些方法。先来简单介绍下线程调度###对于计算机的CPU(以单核为例)，在任意时刻只能执行一条指令，每个线程只有获得CPU的使用权才能执行指令。当有多个处于可运行状态的线程在等待CPU，JVM的一项任务就是负责线程的调度。JVM按照特定机制为多个线程分配CPU的使用权过程就是线程调度。线程调度的两种模型：分时调度...
复制链接

扫一扫