java 多线程执行完返回结果 java多线程结束

转载

小屁孩 2023-09-01 09:28:30

文章标签 java 多线程执行完返回结果多线程 java System 主线程 文章分类 Java 后端开发

java 多线程执行完返回结果 java多线程结束_System

方法	说明
setPriority(int newPriority)	更改线程优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程，但现在官方已经不建议使用这个方法了
boolean isAlive()	测试线程是否处于活动状态

1.线程停止

官方已经不推荐使用jdk提供的stop()和destroy()方法了
建议使用一个标志位进行终止变量，则当flag=false，子线程终止运行

public class TestStop extends Thread{

    private boolean flag = true;

    @Override
    public void run(){
            int j = 0;
            while (flag) {
                System.out.println("run方法执行");
                j++;
            }
    }

    public void stopThread(boolean flag){
        this.flag = flag;
    }

    public static void main(String[] args) {
        //创建一个线程对象
        TestStop testStop = new TestStop();

        //调用start()方法开启线程
        testStop.start();
		//主线程判断后 置flag为false
        for (int i=0;i<200;i++){
            System.out.println("主线程执行");
            if(i==199){
                testStop.stopThread(false);
                System.out.println("终止子线程");
            }
        }
    }

}

运行结果：

…
主线程执行
主线程执行
run方法执行
终止子线程

2.线程休眠

要抛出InterruptedException异常
每一个对象都有一把锁，sleep不会释放锁

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep {
	//休眠主线程
    public static void main(String[] args) {
    
        Date startTime = new Date(System.currentTimeMillis());//获取当前时间
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());//刷新时间
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

运行结果：

…
11:07:12
11:07:13
11:07:14
11:07:15

3.线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行态转为就绪态
让cpu重新调度，重新竞争，调度执行看cpu算法

public class TestYield {

    public static void main(String[] args) {

        MyYield myYield = new MyYield();

        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }

}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }
}

运行结果：

a线程开始
b线程开始
a线程结束
b线程结束（结果不一定）

4.线程强制执行

public class TestJoin implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i<100;i++){
            System.out.println("拥有高级会员的线程"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        //主线程
        for(int i = 0;i<100;i++){

            if(i==20){
                //高级会员插队
                thread.join();
            }
            System.out.println("主线程" + i);
        }
    }
}

运行结果：

…
主线程18
拥有高级会员的线程18
主线程19
拥有高级会员的线程19（if判断为true后子线程强制插队）
拥有高级会员的线程20
拥有高级会员的线程21
…

5.观测线程状态

NEW （尚未启动的线程处于此状态）
RUNNABLE（在Java JVM中执行的线程处于此状态）
BLOCKED（被阻塞等待监视器锁定的线程处于此状态）
WAITING（正在等待另一个线程执行特定动作的线程处于此状态）
TIME_WAITING（正在等待另一个线程执行动作到达指定时间的线程处于此状态）
TERMINATED（已退出的线程处于此状态）

//线程对象名.getState()可以得到当前得状态

6.线程的优先级

Java提供一个线程调度器来监视程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪一个线程来执行
线程的优先级用数字表示，范围从1~10
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;
Thread.NORM_PRIORITY = 5;
使用getPriority()和setPriority(int i)改变和获取优先级

public class TestPriority {

    public static void main(String[] args) {
        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);

        t1.setPriority(1);
        t1.start();

        t2.setPriority(6);
        t2.start();

        t3.setPriority(8);
        t3.start();
        
        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
    }

}

class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->>"+Thread.currentThread().getPriority());
    }
}

运行结果：