线程池_线程

线程池

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，
但是严格意义上讲 Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService 。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用 Executors 工程类来创建线程池对象。
Executors类中有个创建线程池的方法如下：

• public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对 象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
• public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行。

Future接口：用来记录线程任务执行完毕后产生的结果。

使用线程池中线程对象的步骤：

1. 创建线程池对象；
2. 定义类实现Runnable接口或Callable接口；
3. 重写run()方法或call()方法；
4. 创建Runnable或Callable实现类对象；
5. 使用线程池来提交任务；
6. 关闭线程池(一般不做)。

Runnable实现类代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
       } catch (InterruptedException e) {
            e.printStackTrace();
       }
        System.out.println("教练来了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池");
   }
}

线程池测试类：

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        // 创建Runnable实例对象
        MyRunnable r = new MyRunnable();
        //自己创建线程对象的方式
        // Thread t = new Thread(r);
        // t.start(); ---> 调用MyRunnable中的run()
        // 从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        // 再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
        // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
         // 将使用完的线程又归还到了线程池中
        // 关闭线程池
        //service.shutdown();
   }
}

Callable 接口

Callable 接口其实和Runnable接口一样是用来放在子线程上执行的代码（任务）；
Callable 接口中也只有一个抽象方法 call()，这个抽象方法是有返回值的，返回值是泛型，而且可以抛出异常

ExecutorService 中的方法：

• Future submit(Callable task) : 获取线程池中的某一个线程对象，并执行.

Future :表示计算的结果.

Future中的方法：

• V get() : 获取计算完成的结果。

public class ThreadPoolDemo2 {
    public static void main(String[] args) throws Exception {
        // 创建线程池对象
      ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        // 创建Runnable实例对象
        Callable<Double> c = new Callable<Double>() {
            @Override
            public Double call() throws Exception {
                return Math.random();
           }
       };
        // 从线程池中获取线程对象,然后调用Callable中的call()
        Future<Double> f1 = service.submit(c);
        // Futur 调用get() 获取运算结果
        System.out.println(f1.get());
        Future<Double> f2 = service.submit(c);
        System.out.println(f2.get());
        Future<Double> f3 = service.submit(c);
        System.out.println(f3.get());
   }
}

线程池小案例：

需求: 使用线程池方式执行任务,返回1-n的和
分析: 因为需要返回求和结果,所以使用Callable方式的任务

代码：

public class Demo04 {
    public static void main(String[] args) throws ExecutionException,InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        SumCallable sc = new SumCallable(100);
        Future<Integer> fu = pool.submit(sc);
        Integer integer = fu.get();
        System.out.println("结果: " + integer);
        
        SumCallable sc2 = new SumCallable(200);
        Future<Integer> fu2 = pool.submit(sc2);
        Integer integer2 = fu2.get();
        System.out.println("结果: " + integer2);
        pool.shutdown();
   }
}

SumCallable.java

public class SumCallable implements Callable<Integer> {
    private int n;
    public SumCallable(int n) {
        this.n = n;
   }
    @Override
    public Integer call() throws Exception {
        // 求1-n的和?
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
       }
        return sum;
   }
}

小结：我们发现有了线程池后，线程的操作都是固定的步骤，我们的重点放在任务上.

======================================================================================

线程

创建线程的两个方式

1. 定义一子个类继承 Thread 类
   class Ticket extends Thread{}

2. 定义一个类实现 Runnable 接口
   class Ticket implements Runnable{}

推荐使用第二种，那么第二种方式有什么好处呢？

1. 实现接口的方式还可以继承其他类
2. 实现接口方式 Runnable 负责任务， Thread 负责创建线程，将任务和线程的创建分开，降低耦合性

什么是线程安全问题？出现线程安全问题的条件是什么？

线程安全问题：多线程操作共享数据时，导致共享数据出错（具体案例在我的另一篇文章：https://blog.youkuaiyun.com/RookiexiaoMu_a/article/details/88623375
出现线程安全问题的条件：

• 有多个线程
• 有共享数据
• 有多条语句操作共享数据

tips:
在我的上一篇博客（就是上面的链接）中我们知道解决线程安全问题可以使用同步代码块、同步方法、和Lock锁。
其中同步方法、同步代码块涉及到一个同步锁的问题，那同步锁是谁？
对于非static方法，同步锁就是this。
对于static方法，同步锁就是当前方法所在类的字节码对象名（类名.class）

跟线程相关的一些方法

在 Object 类中有这样两个方法：

• void wait() 哪个线程执行 wait() 方法，这个线程就等待
• void notify() 唤醒正在等待的单个线程

tips:
wait和notify必须要在同步代码块中，使用锁对象调用
wait() 会释放锁，sleep() 不会

在这里估计小伙伴们会有这样一个疑问：

面试题：为什么wait()和notify()方法放在Object类中

答：wait()和notify()使用锁对象调用，而任何对象都可以作为锁，所以这两个方法就放在 Object 类中