Java中的多线程（二）---线程的使用

最新推荐文章于 2024-07-22 14:15:06 发布

程序员不需要码子

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量139

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_44918667/article/details/124918929

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、线程的使用

1.终止线程

如果我们想在一个线程中终止另一个线程我们一般不使用JDK提供的stop()/destroy() 方法(它们本身也被 JDK 废弃了)。通常的做法是提供一个 boolean 型的终止变量，当这个变量值为 false 时，则终止线程的运行。

package 包1;

import java.io.IOException;

/*
* 终止线程
* */
public class StopThread implements Runnable{
//设置线程开始/终止标识符
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        System.out.println(Thread.currentThread().getName()+"线程开始！");
        while(flag){
            System.out.println(Thread.currentThread().getName()+"---"+i++);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程结束！");
    }
    public void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"线程开始！");
        StopThread stopThread = new StopThread();
        Thread thread = new Thread(stopThread);
        thread.start();
        try {
            System.in.read(); //当我们读到从键盘中输入的内容的时候，程序继续往下进行
        } catch (IOException e) {
            e.printStackTrace();
        }
        stopThread.stop();
        System.out.println("主线程结束！");

    }
}

2.暂停当前线程执行sleep/yield

暂停线程执行常用的方法有 sleep()和 yield()方法，这两个方法的区别是：

sleep()方法：可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状
yield()方法：可以让正在运行的线程直接进入就绪状态，让出 CPU 的使用权。

sleep 方法的使用

package 包1;
public class SleepThread implements Runnable{
    private boolean flag = true;
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始。");
        for(int  i = 0 ;i < 20; i++){
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+"---"+i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程结束。");
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"线程开始。");
        Thread thread = new Thread(new SleepThread());
        thread.start();
        System.out.println(Thread.currentThread().getName()+"线程结束！。");
    }
}

yield方法的使用

yield()方法的作用：暂停当前正在执行的线程，并执行其他线程。

yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。因此，使用 yield()的目的是让具有相同优先级的线程之间能够适当的轮换执行。但是，实际中无法保证 yield()达到让步的目的，因为，让步的线程可能被线程调度程序再次选中。

使用 yield 方法时要注意的几点：

yield 是一个静态的方法。
调用 yield 后，yield 告诉当前线程把运行机会交给具有相同优先级的线程。
yield 不能保证，当前线程迅速从运行状态切换到就绪状态。
yield 只能是将当前线程从运行状态转换到就绪状态，而不能是等待或者阻塞状态。

package 包1;

public class YieldThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始·");
        for(int i =0; i<10 ;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if ("Thread-0".equals(Thread.currentThread().getName())){
                Thread.yield();
            }
            if (i == 1){
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName()+ "---" +i);
        }

        System.out.println(Thread.currentThread().getName()+"线程结束·");
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println(Thread.currentThread().getName()+"线程开始·");
        Thread thread = new Thread(new YieldThread());
        Thread thread1 = new Thread(new YieldThread());
        thread.start();
        thread1.start();
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName()+"线程结束·");
    }
}

3.线程的联合

当前线程邀请调用方法的线程优先执行，在调用方法的线程执行结束之前，当前线程不能再次执行。线程 A 在运行期间，可以调用线程 B 的 join()方法，让线程 B 和线程 A 联合。这样，线程 A 就必须等待线程 B 执行完毕后，才能继续执行。

3.1Jion方法的使用

join()方法就是指调用该方法的线程在执行完 run()方法后，再执行 join 方法后面的代码，即将两个线程合并，用于实现同步控制。

package 包1;

class A implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始！ ");
        for ( int i = 0; i<10;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程结束！！ ");
    }
}

public class JoinThread {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"线程开始！ ");
        Thread thread = new Thread(new A());
        thread.start();
        try {
            thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i<10;i++){
            try {
                thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" "+i);
            if (i == 2){
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程结束！！ ");
    }
}

当我们进入main方法中运行时候，主线程开始工作，在主线程中使用jion方法让main线程停下来等thread对象的线程运行完之后再开始执行。

接下来我们看一个案例：

多线程联合案例：

package 包1;

class FatherThread implements Runnable{
    @Override
    public void run() {
        System.out.println("爸爸想要抽烟，发现烟没了！");
        System.out.println("爸爸想让儿子去买烟!");
        Thread thread = new Thread(new SonThread());
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("儿子拿着钱跑路了！爸爸出门去找！");
        }

        System.out.println("儿子买烟回来了,爸爸高兴地接过烟,并给了儿子零钱！。");
    }
}
class SonThread implements Runnable{
    @Override
    public void run() {
        System.out.println("儿子买烟需要十分钟！");
        for(int i =1  ;i<=10; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("儿子买烟的第"+i+"分钟!");
        }
        System.out.println("儿子买烟回来了！");
    }
}



public class JoinDemo {
    public static void main(String[] args) {
        System.out.println("爸爸和儿子买烟的故事！");
        FatherThread fatherThread = new FatherThread();
        Thread thread = new Thread(fatherThread);
        thread.start();
    }
}

当我们熟悉线程的运作之后我们就很容易看出该线程中的输出关系。。。。

Thread类中的其他常用方法:

获取当前线程名称：

方式一：

this.getName()获取线程名称，该方法适用于继承 Thread 实现多线程方式

class GetName1 extends Thread{ @Override
public void run() { System.out.println(this.getName());
}
}

方式二：

Thread.currentThread().getName()获取线程名称，该方法适用于实现 Runnable 接口实现多线程方式。

class GetName2 implements Runnable{

@Override
public void run() { System.out.println(Thread.currentThread().getName());
}
}

设置线程的名称

方式一：

通过构造方法设置线程1名称

方式二：

通过setName设置线程名称

package 包1;

class SetName01 extends Thread{
    //Thread方法一：定义有参构造方法，线程名直接传给Thread
    public  SetName01(String name){
        super(name);
    }
//    该线程的线程体直接输出线程名
    @Override
    public void run() {
        System.out.println(this.getName());
    }
}
class SetName implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

public class SetNameThread {
    public static void main(String[] args) {
        SetName01 setName = new SetName01("name1");
        setName.start();
        setName.setName("name2");
//        Runnable接口实现
        Thread t1 = new Thread(new SetName());
        t1.setName("name3");
        t1.start();
        
    }

}

判断当前线程是否存活：

isAlive()方法：判断当前的线程是否处于活动状态。

活动状态是指线程已经启动且尚未终止，线程处于正在运行或准备开始运行的状态，就认为线程是存活的。

package 包1;
/*
* 判断线程是否存活
* */
public class IsAliveDemo implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" "+Thread.currentThread().isAlive()+ "2");
    }

    public static void main(String[] args) {
        IsAliveDemo isAliveDemo = new IsAliveDemo();
        Thread thread =new Thread(isAliveDemo);
        System.out.println(thread.getName()+" "+thread.isAlive()+ "1");
        thread.start();
        System.out.println("主线程运行结束！");
        System.out.println(Thread.currentThread().getName()+" "+Thread.currentThread().isAlive()+ "3");
    }
}

运行结果：

线程的优先级

什么是线程的优先级

每一个线程都是有优先级的，我们可以为每个线程定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程的优先级用数字表示，范围从 1 到 10，一个线程的缺省优先级是 5。

Java 的线程优先级调度会委托给操作系统去处理，所以与具体的操作系统优先级有关，如非特别需要，一般无需设置线程优先级。

注意：线程的优先级，不是说哪个线程优先执行，如果设置某个线程的优先级高。那就是有可能被执行的概率高。并不是优先执行。

线程优先级的使用

package 包1;
class Priority implements Runnable{
    private int num = 0;
    private boolean flag = true;

    @Override
    public void run() {
        while(this.flag){
            System.out.println(Thread.currentThread().getName()+" "+num++);
        }
    }
    public void stop(){
        this.flag = false;
    }
}
public class PriorityThread{
    public static void main(String[] args) {
        Priority p1 = new Priority();
        Priority p2 = new Priority();

        Thread thread = new Thread(p1,"线程一");
        Thread thread2 = new Thread(p2,"线程二");

        System.out.println(thread.getPriority()+"  ");
        System.out.println(thread2.getPriority());
        //        Thread.MIN_PRIORITY = 1;
        thread2.setPriority(Thread.MIN_PRIORITY);
//Thread.MAX_PRIORITY = 10;
        thread.setPriority(Thread.MAX_PRIORITY);

        thread.start();
        thread2.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        p1.stop();
        p2.stop();
    }
}

守护线程

什么是守护线程

在 Java 中有两类线程：

User Thread(用户线程)：就是应用程序里的自定义线程。
Daemon Thread(守护线程)：比如垃圾回收线程，就是最典型的守护线程。

守护线程（即 Daemon Thread），是一个服务线程，准确地来说就是服务其他的线程，这是它的作用，而其他的线程只有一种，那就是用户线程。

守护线程特点：

守护线程会随着用户线程死亡而死亡。

守护线程的使用

package 包1;
/*
* 守护线程类
* */
class Daemon implements  Runnable{
    @Override
    public void run() {
        for(int i =0 ; i<20;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/*
* 给用户线程设置守护线程！
* */
class UserDaemon implements Runnable{
    @Override
    public void run() {
        Daemon daemon1 = new Daemon();
        Thread thread1 = new Thread(daemon1,"Daemon1");
//        设置为守护线程
        thread1.setDaemon(true);
        thread1.start();
        for (int i = 0;i<10;i++){
            System.out.println(Thread.currentThread().getName() + i);
            try {
                thread1.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}


public class DaemonThread {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开始！");
        Thread thread = new Thread(new UserDaemon(),"UserDaemon");
        thread.start();
        thread.sleep(1000);
        System.out.println("主线程结束!");


    }
}

程序员不需要码子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中的多线程（二）---线程的使用

一、线程的使用1.终止线程如果我们想在一个线程中终止另一个线程我们一般不使用JDK提供的stop()/destroy() 方法(它们本身也被 JDK 废弃了)。通常的做法是提供一个 boolean 型的终止变量，当这个变量值为 false 时，则终止线程的运行。package 包1;import java.io.IOException;/** 终止线程* */public class StopThread implements Runnable{//设置线程开始/终止标识符
复制链接

扫一扫