java多线程

多线程

实现多线程三种方法，这里说两种

第一：继承Thread类

public class TestThread extends Thread{

    /**
     * 1.通过继承Thread类来创建多线程
     * 2.重写run方法，在run方法中执行子线程
     * 3.主方法中创建对象，调用start（）方法
     * 4.调用start（）方法是将子线程交给CPU，什么时候执行，归CPU管
     * 5.调用start（）后，程序继续向下执行，不管子线程是否执行完成
     *      相当于之前单线程时，程序从上向下依次执行，但，现在是
     *      在调用子方法后，变成两条线向下执行
     */


    private String str;
    //主方法
    public static void main(String[] args) {

        TestThread t1  = new TestThread("子线程1");
        TestThread t2  = new TestThread("子线程2");
        TestThread t3  = new TestThread("子线程3");

        t1.start();
        t2.start();
        t3.start();

        for (int i = 0;i < 20;i ++) {
            System.out.println("主线程");
        }
    }

    //构造器
    public TestThread(String str){
        this.str = str;
    }

    //重写run方法
    @Override
    public void run(){

        for (int i = 0;i <  20;i ++){
            System.out.println(str);
        }
    }

}

第二：实现Runnable接口，推荐使用这种方法

public class TestThread implements Runnable{

    /**
     * 通过实现接口来实现多线程
     *
     */
    
    private String str;
    //主方法
    public static void main(String[] args) {

        TestThread t1  = new TestThread("子线程1");
        TestThread t2  = new TestThread("子线程2");
        TestThread t3  = new TestThread("子线程3");

        //在这里需要创建Thread的对象，将继承Runnable接口的类的对象丢进去，
        // 然后调用start()方法
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();

        for (int i = 0;i < 20;i ++) {
            System.out.println("主线程");
        }
    }

    //构造器
    public TestThread(String str){
        this.str = str;
    }

    //重写run方法
    @Override
    public void run(){

        for (int i = 0;i <  20;i ++){
            System.out.println(str);
        }
    }

}

推荐使用Runnable接口，做到多个线程共享一份资源

public class TestThread implements Runnable{

    /**
     * 通过实现接口来实现多线程
     *
     */

    private int str = 99;
    //主方法
    public static void main(String[] args) {

        TestThread t  = new TestThread();

        new Thread(t,"线程1").start();
        new Thread(t,"线程2").start();
        new Thread(t,"线程3").start();
    }


    //重写run方法
    @Override
    public void run(){
        
        while(str > 0){
            System.out.println(Thread.currentThread().getName() + "--->" + str--);
        }
        
    }

}

线程的状态

• 新生状态：指的是：Thread t = new Thread(); 这个状态，拥有了自己的工作空间
• 就绪状态：指的是：t.start(); 这个状态，
  • 就绪状态可以由新生状态进入
  • 由阻塞事件解除，也会到就绪状态
  • 运行中通过yield()方法让出CPU，进入就绪状态
  • JVM通过算法切换线程，让当前线程进入就绪状态
• 运行状态：指的是：被CPU调用的这个状态
• 阻塞状态：指的是：线程因各种原因进入阻塞状态的状态
  • sleep()，join()，wait()方法都会阻塞线程
  • IO流会阻塞线程
• 死亡状态：线程执行完毕，或退出。

线程终止

• 不建议使用stop方法，存在各种问题
• 可以在外部新建一个布尔型值，在run()方法内部检测这个值，如果为false，跳出
• 在类里新建一个方法控制这个值，以达到控制线程的目的

线程的睡眠

• 线程睡眠（sleep）指的是线程占用资源却不用，睡眠结束后重新进入就绪状态
• 而wait方法则是不占用资源

yield()方法，礼让线程

• 在线程中Thread.yield();即可调用方法
• 该方法是将进程重新变回就绪状态，重新共同竞争CPU资源

join()阻塞线程

• 调用方法：在线程中通过Thread对象调用：new Thread().join(传参表示多少
  毫秒后，CPU不在管你，重新调度);
• 指的是在线程中阻塞当前线程，等其他线程执行完毕，或传参时间到了，再回CPU重新调度

Thread.State线程状态

• NEW：新生状态
• RUUNABLE：就绪和运行状态
• BLOCKED：执行wait()方法后的状态
• WAITING：执行sleep()方法后的状态
• TIMED_WAITING：执行join()方法后的状态
• TERMINATED：死亡状态
• Thread t = new Thread();
  State s = t.getState();
  s为线程状态
  通过Thread.State.TERMINATED可获得线程死亡状态的状态与线程当前状态对比
  Thread.State.TERMINATED == s;

线程优先级

• NORM_PRIORITY：默认优先级，为5
• MAX_PRIORITY：最大优先级，为10
• MIN_PRIORITY：最小优先级，为1
• Thread t = new Thread();
  t.setPriority(可以为数字);
  设置线程优先级，数字越大，概率越高
  t.getPriority():获得线程优先级

守护线程

• 线程分为两大类：用户线程和守护线程
• 一般建立的默认线程为用户线程
• 虚拟机等待用户线程执行完毕才停止，但是不会等待守护线程
• 守护线程为用户线程服务

Thread t = new Thread();
t.setDaemon(true);	//将用户线程调整为守护线程
t.start();