关于线程和进程的基本概念☛操作系统中线程和进程的概念理解 这篇文章已经有了很详细的解释, 接下来主要来讲讲线程等待与线程休眠 / 线程的几种状态 / Runnable 和 Callable 与 Thread 的概念和区别及 Executor 框架是什么样的.

在学习下面的知识之前, 简单问一下 Thread 中的 run 和 start 的区别是什么?

其实 run 就是一个普通的方法, 并没有创建新的线程, 输出也是在原线程中执行的; 而 start 创建了一个新的线程, 在新的线程中执行输出.

1 线程等待与线程休眠

  关于线程之间是并发执行的, 谁先执行谁后面执行程序员是无法感知的, 这都是由内核系统来进行控制, 也就是说我们创建了一个新的线程, 那么任务是让主线程执行还是新线程执行这是无法保证的, 虽然无法保证谁先去执行, 但是我们能控制哪个线程先结束, 哪个线程后结束, 这里就用到了 join 方法;

  执行 join 方法的线程就会阻塞, 一直阻塞到对应的线程结束之后, 才会继续执行(如线程 A 调用了线程 B 的 join 方法, 此时 A 就会一直阻塞, 一直阻塞到 B 这个线程执行结束); 线程等待存在的意义就是为了控制线程结束的先后顺序.

 关于线程休眠: 线程 A 调用了 sleep, A 就会被阻塞, 阻塞到 sleep 指定的时间.

2 线程一共有哪些状态

• NEW: Thread 对象有了, 但是 PCB 还没有, 也就是任务安排了, 但是还没有开始执行;
• RUNNABLE: 代表此线程正在 CPU 上执行或者是即将到 CPU 上执行, PCB 在就绪队列中, 随时可能被调度到;
• WAITING: wait 方法(当操作条件不成熟就等待, 操作流程: 释放锁->等待通知->收到通知后重新获取锁->继续往下执行, wait 方法必须在 synchronized 代码块内部使用)导致的, 此线程暂时停了下来, 不会继续到 CPU 上执行, 等时机成熟后才有机会再去执行;
• TIMED_WAITING: sleep 方法导致的;
• BLOCKED: 等待锁导致的;
• TERMINATED: 内核中的线程已经结束了, 也就是 PCB 没了, 但是代码中的 Thread 对象还在, 这时候就等着 GC 来回收吧.

3 Runnable() 接口实现多线程

  Thread 的核心功能就是进行线程的启动, 如果一个类为了实现多线程而去直接继承 Thread 类就会出现单继承的局限问题, 因此 java 中又提供了另外的实现模式, 使用 Runnable 接口去实现多线程;

static class Thread1 implements Runnable {
        private String str;

        public Thread1(String str) {
            this.str = str;
        }

        @Override
        public void run() {
            for (int i = 0; i < 2; i++) {
                System.out.println(this.str + ",i = " + i);
            }
        }
    }

    public static void main(String[] args) {
        Thread1 t1 = new Thread1("t1");
        Thread1 t2 = new Thread1("t2");
        Thread1 t3 = new Thread1("t3");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }

如上代码就是通过 Runnable 接口来实现多线程的例子, 因为 Thread1 类中不是 Thread 类实现的, 因此没有了 start 方法, 所以 main 方法启动这三个线程的时候我又使用 Thread 提供的构造方法; 当然这里也可以直接写成 Thread t1 = new Thread(new Thread1) 这种形式.

运行结果:

这里需要注意, 所线程的启动永远都是 Thread 类的 start() 方法.

关于 Thread 和 Runnable 的区别:

• 首先从使用形式来看, Runnable 实现多线程可以避免单继承的局限问题;
• 其实 Thread 类是 Runnable 接口的子类, 并且 Thread 类覆写了 Runnable 接口的 run() 方法;
  
  
• Runnable 实现的多线程的程序类可以更好的描述出程序共享的概念.
  
  

4 Callable 实现多线程

static class Thread2 implements Callable<String> {
        private int num = 3;

        @Override
        public String call() throws Exception {
            while (num > 0) {
                System.out.println("num = " + num--);
            }
            return "打印完成";
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> task = new FutureTask<>(new Thread2());
        new Thread(task).start();
        System.out.println(task.get());
    }

运行结果:

• Runnable 的 run() 方法没有返回值, 其设计遵循了主方法的设计原则, 也就是线程开始了就别想回头, 但是很多时候我们需要用到一些返回值, 例如某些线程执行完成后可能带来的一些返回结果, 这种情况下就只能使用 Callable 来实现多线程了.
• 当然这种情况多线程的启动还是只有 Thread 类中的 start() 方法可以实现.

关于 Runnable 和 Callable 之间的区别:

• Runnable 指的是一个对象能够被执行, 而 Callable 则是针对一个函数或者一个方法能够被调用;
• Runnable 通过实现接口中的 run() 方法来定义可执行代码, 而 Callable 则是通过实现接口中的 call() 方法来定义可调用的代码;
• Runnable 可以通过创建线程来执行, 而 Callable 则是通过作为 FeatureTask 的参数来使用的.

5 Executor 框架

  Java 线程启动时会创建一个本地操作系统线程, 当线程终止时, 本地操作系统线程也会被回收, 并且操作系统会调度所有线程并将它们分配给可用的 CPU.

  在上层, Java 多线程程序通常会把应用分割成若干个任务, 然后使用调度器 (Executor 框架) 将这些任务映射到固定数量的线程; 在底层, 操作系统内核将这些线程映射到硬件处理器上.

  Executor 框架最核心的类就是 ThreadPoolExecutor, 也是线程池的实现类, 通过 Executor 框架的工具类 Executors, 可以创建三种类型的 ThreadPoolExecutor:

• public static ExecutorService new CachedThreadPool(): 创建无大小限制的线程池;
• public static ExecutorService new FixedThreadPool(int nThreads): 创建固定大小的线程池;
• public static ExecutorService newSingleThreadExeeeeeecutor(): 单线程池.