Runnable与Thread类详解

Runnable类是一个接口，包含一个抽象方法，run

public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

Thread类实现了Runnable接口同时包含以下方法

• run方法，需要在线程中执行的逻辑
• currentThread方法，获取当前所在的线程，返回为一个Thread对象
• yield 方法，暂时释放自己持有的cpu资源
• start方法 启动一个线程，并执行当前线程的run方法
• join方法 a线程调用b线程的join方法，a线程会阻塞，直到b线程执行结束，a线程会继续执行
• stop方法（已过时），当执行stop方法时，强制停止当前线程
• sleep方法，让当前线程阻塞指定毫秒数
• isAlive方法 判断当前线程是否存活，返回true或者false
• setPriority方法，设置线程的优先级

/**
    * The minimum priority that a thread can have.
    * 最小优先级
    */
   public final static int MIN_PRIORITY = 1;

  /**
    * The default priority that is assigned to a thread.
     * 默认优先级
    */
   public final static int NORM_PRIORITY = 5;

   /**
    * The maximum priority that a thread can have.
     * 最大优先级
    */
   public final static int MAX_PRIORITY = 10;

• getPriority方法，获取当前线程的优先级
• Thread.State,Thread内部枚举类，用来记录当前线程的生命周期

public enum State {
        // 线程新建了，但是还没有start
        NEW,
       // 线程执行起来了，就是调用了线程的start方法之后
        RUNNABLE,
      // 阻塞状态，当多个线程执行同一个同步代码块儿时，同步代码快被其他线程占用，当前线程就为阻塞态
        BLOCKED,
      // 等待 wait(),join()等方法调用了之后，即不知道等待多久
        WAITING,
      // 带时间的等待，wait(time),join(time)方法调用了之后，即知道等待多久
        TIMED_WAITING,
      // 线程执行完成
        TERMINATED;
    }

创建线程的方式
1.继承Thread方式实现,重写run方法

class MyThread extends Thread {

    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}

2.实现Runnable接口的方式实现

/**
 * create by elitetyc
 * date：2020/3/5
 * desc：
 * 1.创建类实现Runnable接口
 * 2.实现run方法
 * 3.创建实例对象
 * 4.将实例对象传递给Thread构造函数，新建Thread对象，并调用start方法
 **/

//步骤1
public class RunnableTest implements Runnable {

//    步骤2
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
            }

        }
    }

    public static void main(String[] args) {
//        步骤3
        RunnableTest runnableTest = new RunnableTest();
//        步骤4
        new Thread(runnableTest).start();
    }
}

比较两种创建线程的方式
开发中优先选择实现Runnable方式来创建线程

• 因为类为单继承，如果使用继承Thread方式创建线程了，可能导致该类不能再继承其他类
• 多个线程之间又共享数据时，使用实现Runnable接口的方式可以天然达到共享数据的效果（例如卖票系统）

/**
 * create by elitetyc
 * date：2020/3/5
 * desc：创建3个窗口卖票，一共100张票
 **/


public class RunnableWindowTest{
    public static void main(String[] args) {
        RunnableWindow runnableWindow = new RunnableWindow();
        new Thread(runnableWindow,"窗口1").start();
        new Thread(runnableWindow,"窗口2").start();
        new Thread(runnableWindow,"窗口3").start();

    }
}


class RunnableWindow implements Runnable {

    private int ticket=100;

    @Override
    public void run() {
//        同步锁，防止多线程安全问题
        synchronized (this){
            while (true){
                if (ticket>0){
                    System.out.println(Thread.currentThread().getName()+"：卖出票号"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }


}