Runnable与Thread类详解

朱雀 2021-09-19 07:58 350阅读 0赞

**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;
                    }
                }
            }
        }
    
    
    }