线程方法学习

  列举了几个线程常用方法。

线程停止

1. 建议线程正常停止，利用次数，不建议死循环
2. 建议使用标志位，设置一个标志位
3. 不要使用stop或者destroy等过时或JDK不建议使用的法

public class Demo1 implements Runnable {
    //设置一个标识位
    private boolean flag = true;

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

    //设置一个公开的方法停止线程，转换标志位
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        Demo1 d = new Demo1();
        new Thread(d).start();
        for (int i = 0; i < 10000; i++) {
            System.out.println("main" + i);
            if (i == 9000) {
                //调用stop方法切换标志位，让线程停止
                d.stop();
                System.out.println("该线程停止");
            }
        }
    }
}

线程休眠

  sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。
  注意：sleep()和wait()是有区别的。wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时，也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。但是，wait()会释放对象的同步锁，而sleep()则不会释放锁。

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

//sleep的功能
public class Demo2 {

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

    }
    public static void TimeDown(int num) throws InterruptedException {
        //模拟倒计时的功能
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num < 0)
                break;
        }
    }
}

线程礼让

  只是让原来已经执行的线程先退出来重新竞争资源，还是得看CPU分配。

public class Demo3 {
    public static void main(String[] args) {
        MyYield m = new MyYield();
        new Thread(m, "a").start();
        new Thread(m, "b").start();
        new Thread(m, "c").start();
    }
}

class MyYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//线程礼让
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}

线程插队

  使用join()方法，可实现"插队"效果。当插队的线程运行结束后，其他线程将继续执行。

public class Demo4 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程VIP来了！" + i);
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        //启动我们的线程
        Demo4 j = new Demo4();
        Thread thread = new Thread(j);
        thread.start();
        //主线程
        for (int i = 0; i < 500; i++) {
            if (i == 200) {
                thread.join();//插队
            }
            System.out.println("main" + i);
        }
    }
}

线程优先级

  可以通过setPriority(优先级)方法设置线程的优先级，优先级从1~10。
  注意：优先级高的不一定先行执行；

//测试线程的优先级
public class Demo5 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "----" + Thread.currentThread().getPriority());
        Mypriority mypriority = new Mypriority();
        Thread t1 = new Thread(mypriority);
        Thread t2 = new Thread(mypriority);
        Thread t3 = new Thread(mypriority);
        Thread t4 = new Thread(mypriority);
        Thread t5 = new Thread(mypriority);
        Thread t6 = new Thread(mypriority);

        //先设置优先级，再启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();

        t5.setPriority(3);
        t5.start();

        t6.setPriority(10);
        t6.start();

    }
}

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

守护线程

  守护线程，在没有用户线程可服务时会自动离开。优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。
  设置：通过setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在线程对象创建之前，用线程对象的setDaemon方法。

thread.setDaemon(true);//默认是false，表示保护线程。正常的线程都是用户线程。