标签：Java Thread System 线程 println 多线程 public out

三.线程状态

1.线程停止

不推荐使用jdk提供的stop(),destory()方法，可自定义公开stop()方法,通过设置标志位让其停止。

public class Stop implements Runnable {

    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("running..."+i++);
        }
    }

    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        Stop s = new Stop();
        new Thread(s).start();
        for (int i = 0; i < 100 ; i++) {
            if (i == 75){
                s.stop();
                System.out.println("stop...");
            }
            System.out.println("main"+i);
        }
    }
}

2.线程休眠

sleep()指定当期线程阻塞的毫秒数，时间达到后进入就绪状态。每一个对象都有一个锁，sleep不释放锁。

public class Sleep {
    public static void main(String[] args) {
        Date start = new Date(System.currentTimeMillis());
        // 获取系统当前时间
        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(start));
                start = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3.线程礼让

暂停执行当前线程，转为就绪状态，系统执行去执行其他线程，但具体执行哪个线程由调度器决定。

public class Yield implements Runnable{
    
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程暂停执行");
    }
    
    public static void main(String[] args) {
        Yield y = new Yield();
        new Thread(y,"a").start();
        new Thread(y,"b").start();
    }
}

4.join(插队)

指定的线程合并到当前执行的线程中，即交替执行转为顺序执行，待该指定线程执行完之后，再执行其他线程，此时其他线程阻塞。

public class Join implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("thread"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Join j = new Join();
        Thread t = new Thread(j);
        t.start();
        for (int i = 0; i < 200; i++) {
            if (i == 88){
                t.join();
            }
            System.out.println("main"+i);
        }
    }
}

5.观测线程状态

线程状态。 线程可以处于以下状态之一：

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

一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

通过Thread.getState()获取线程状态

public class State implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 6; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("thread");
    }

    public static void main(String[] args) {
        State s = new State();
        Thread t = new Thread(s);
        Thread.State state = t.getState();
        // 获取线程状态
        System.out.println(state);

        t.start();
        state = t.getState();
        System.out.println(state);

        while (state != Thread.State.TERMINATED){
            try {
                Thread.sleep(100);
                state = t.getState();
                System.out.println(state);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

标签：Java,Thread,System,线程,println,多线程,public,out
来源： https://www.cnblogs.com/tao-gak567/p/15361043.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。