码迷,mamicode.com
首页 > 编程语言 > 详细

线程的常用方法一

时间:2020-04-17 00:38:57      阅读:55      评论:0      收藏:0      [点我收藏+]

标签:ack   ext   延时   new   裁判   sys   ring   --   循环   

线程

停止线程比较好的方法

1.不要使用JDK已经废弃的stop()等方法。

2.设置外部标志位,控制线程运行,理论上是让他自己停止

3.让他自己停下来

public class ThreadStop implements Runnable{
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("新线程在运行·········"+i);
        }
    }
    public void stop(){//通过外部标志位来结束线程
        this.flag = false;
    }
    public static void main(String[] args) {
        ThreadStop threadStop = new ThreadStop();
        new Thread(threadStop).start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main"+i);
            if(i==90){
                threadStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

模拟延迟

Thread.sleep(1000);//它不仅仅可以让线程延迟,他可以让他所在的代码块延时1000ms
package Thread;

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

public class ThreadSleep {
    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();
            }
        }
    }
}

yield()方法,礼让。

线程礼让yield。未必会成功,礼让是两个先出来,然后再进去,谁先进去也不确定

Thread.yield();//就像跑步比赛,小明在前面跑,小王追不上。现在裁判(yield())把他们喊到起点,小王和小明跑的更快全靠运气。

join()方法,插队法

public class ThreadJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我插队进来的"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadJoin threadJoin = new ThreadJoin();
        Thread thread = new Thread(threadJoin);
        thread.start();
        for (int i = 0; i < 20; i++) {
            if(i==10){
                thread.join();
            }
            System.out.println("MainThread在运行" + i);
        }
    }
}

备注:插队只能让他马上执行,执行多久,是看运气的。可能他本来就可以执行,甚至本来就在执行

线程状态

  • lambda表达式,获取一个线程的对象可方便了
  • Thread.State是枚举类型,分别是线程的几种状态
  • thread.getState()获取的是一个进程当前的状态 thread是一个进程对象名。
  • 线程死亡之后不可能再被创建
Thread.State state = thread.getState();//state座位进程状态枚举对象,把thread对象.getState赋值给state。
public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{//lambda表达式,获取一个线程的对象可方便了
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("for循环结束了,线程不要阻塞了");
        });     
        System.out.println(state);//初始线程的状态
        thread.start();//启动线程
        System.out.println(thread.getState());//获取执行后的状态
        while (thread.getState() != Thread.State.TERMINATED){
            Thread.sleep(1000);
            System.out.println(thread.getState());//获取当前的状态
        }
    }
}

线程优先级

先设置优先级,然后再启动。

优先级数大,优先级高,优先被执行。但是低的未必一定会后执行。只是权重低而已。

t1.setPriority(优先级数);越大越优先。
package Thread;
public class ThreadPriority{
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"----->"+Thread.currentThread().getPriority());
        Priority priority = new Priority();
        Thread t1 = new Thread(priority);
        Thread t2 = new Thread(priority);
        Thread t3 = new Thread(priority);
        Thread t4 = new Thread(priority);
        Thread t5 = new Thread(priority);
        Thread t6 = new Thread(priority);
        Thread t7 = new Thread(priority);
        t1.setPriority(1);
        t1.start();
        t2.setPriority(2);
        t2.start();
        t3.setPriority(3);
        t3.start();
        t4.setPriority(4);
        t4.start();
        t5.setPriority(5);
        t5.start();
        t6.setPriority(6);
        t6.start();
        t7.setPriority(7);
        t7.start();
    }
}
class Priority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"----->"+Thread.currentThread().getPriority());
    }
}

线程的常用方法一

标签:ack   ext   延时   new   裁判   sys   ring   --   循环   

原文地址:https://www.cnblogs.com/li33/p/12716745.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!