Java并发编程（JUC）（一）

今天深度学习了一下java并发编程的相关知识，在这里给大家做一个分享，可能理解不对的地方请大家评论指导，谢谢大家！

首先，由于进程和线程是两个基本的执行单元，在了解并发编程之前我们需要了解一些关于进程和线程的知识（这里只是做大概描述，需要深度了解进程和线程的可查看网上其他教程以及相关书籍）。

什么是进程和线程？

• 进程
  通俗一点讲，进程就是系统中正在运行的程序。
• 线程
  是操作系统能够进行运算调度的独立单位。

进程和线程之间的关系

进程是系统进行资源分配和调度的一个独立单位。而线程是进程的一个实体，是CPU调度和分配的基本单位，它是比进程更小的独立运行的基本单位。

为什么要使用多线程呢？

• 优点
  1、合理使用CPU资源
  2、使用多线程可以使程序影响更快
• 缺点
  1、多线程会使系统设计变得复杂
  2、多线程带来一定的系统性能开销（上下文切换，内存，线程管理）
  3、 多线程竞争会造成死锁
  4、对一些共享变量会造成可见性的问题
  由于多线程使用带来的优势很大，而且多线程带来的问题很多已经得到解决，所以程序设计中，多线程使用不可避免。

下面我们来了解一下线程相关的知识：

线程的状态

线程是具有一定状态的，不同时期的线程状态自然是不一样的，那线程有哪几种状态呢？

• 新建（New）
  线程创建后尚未启动。
• 可运行（Runnable）
  线程可能处于运行状态，也可能处于正在等待CPU分配时间片。
• 阻塞（Blocking）
  线程获取资源时，需要等待其他线程释放该资源的锁，当获取到锁时，结束阻塞。
• 等待（Waiting）
  当线程调用wait()、sleep()方法，线程会进入等待状态。使用wait()方法进入等待需要其他线程唤醒才能结束等待，使用sleep()方法进入等待，则需要等待设置的时间到了之后，等待状态结束。
• 死亡（Terminated）
  线程正常直接结束或者因为异常等其他原因结束

知道了线程的状态之后，线程怎么创建呢？

线程的创建

• 继承Thread类
  Thread类是java的基本线程类，可以通过它来创建线程，但是它的缺陷也很明显：java只支持单继承，使用Thread类不易于程序扩展。

public class ThreadTest {
    public static void main(String[] args) {
        //线程的创建是通过线程类来构造线程实例
        ThreadDemo threadDemo = new ThreadDemo();
        Thread thread  = new Thread(threadDemo);
        //启动线程,线程进入可运行状态，等待CPU分配时间片，分配之后执行run()方法
        thread.start();
    }
}
/**
 * 创建线程的类继承Thread类
 * 覆盖父类中的run方法
 */
class ThreadDemo extends Thread{
    //run方法是线程的执行体，线程需要执行的操作
    @Override
    public void run() {
        System.out.println("我是通过继承Thread类来实现的线程"+Thread.currentThread().getName());
    }
}

• 实现Runnable接口
  相比继承Thread类的方式，实现接口的方式更加易于扩展，因为java支持接口可以被多个实现类实现。

/**
 * 通过实现Runnable接口来实现线程的创建
 */
public class RunnableTest {
    public static void main(String[] args) {
    RunnableImpl runnable = new RunnableImpl();
    //通过RunnableImpl实例来创建线程
    Thread thread = new Thread(runnable);
    //启动线程
        thread.start();
    }
}
/**
 * 实现Runnable接口必须实现run方法
 */
class RunnableImpl implements Runnable{

    @Override
    public void run() {
        System.out.println("我是通过实现Runnable接口来创建的线程"+Thread.currentThread().getName());
    }
}

• 实现Callable接口
  Callable接口对比上面两种方式的好处是：除了实现接口可以易于扩展，还可以返回线程的执行结果，这是上面两张方式没有的。
  java提供Future类来对操作线程执行的结果。

/**
 * 实现Callable接口来创建线程
 * Callable有两种使用方式：
 * 1、配合Thread类来完成线程的创建
 * 2、搭配ExecutorService提供的线程池来创建线程
 */
public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //第一种方式：配合Thread类来完成线程的创建
        CallableImpl callable = new CallableImpl();
        //通过CallableImpl类来构建FutureTask对象
        FutureTask futureTask = new FutureTask(callable);
        //创建线程实例
        Thread thread = new Thread(futureTask);
        //开启线程
        thread.start();
        //通过FutureTask中的get方法获取线程的执行结果，循环打印输出
        List<Integer> list = (List<Integer>) futureTask.get();
        for(Integer o:list){
            System.out.println(o+"---"+thread.currentThread().getName());
        }


    }
}

/**
 * 定义一个线程类
 */
class CallableImpl implements Callable {

    //call方法是线程的执行体，并且附带返回值
    @Override
    public List<Integer> call() throws Exception {
        List<Integer> list = new ArrayList(16);
        for(int i=0; i<10; i++){
            list.add(new Random().nextInt(10));
        }
        return list;
    }
}

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //第二种方式：通过搭配ExecutorService使用线程池来创建线程
        ExecutorService executorService = Executors.newCachedThreadPool();
        CallableImpl callable = new CallableImpl();
        //构建Future对象，并且执行线程
        Future<List<Integer>> future = executorService.submit(callable);
        //关闭ExecutorService
        executorService.shutdown();
        //获取线程执行结果
        List<Integer> list = future.get();
        for (Integer o:list){
            System.out.println(o);
        }
    }
}

/**
 * 定义一个线程类
 */
class CallableImpl implements Callable {

    //call方法是线程的执行体，并且附带返回值
    @Override
    public List<Integer> call() throws Exception {
        List<Integer> list = new ArrayList(16);
        for(int i=0; i<10; i++){
            list.add(new Random().nextInt(10));
        }
        return list;
    }
}

• 使用线程池创建
  ExecutorService中提供三种线程池
  • 1、FixedThreadPool：线程数固定的线程池
  • 2、CachedThreadPool：线程数量根据任务动态调整的线程池
  • 3、SingleThreadPool：仅单线程执行的线程池
    线程池创建线程可以参考Callable 搭配ExectorService来创建线程的例子。线程池是工作当中最常用的方式，通过线程池维护线程数量，不会因为过多的创建线程而消耗系统资源。

这篇文章暂时先聊到这里，其他后续补上！