【并发编程】- 多线程与并发编程

1、什么情况下应该使用多线程

线程出现的目的是什么？解决进程中多任务的实时性问题？其实简单来说，也就是解决“阻塞”的问题，阻塞的意思就是程序运行到某个函数或过程后等待某些事件发生而暂时停止 CPU 占用的情况，也就是说会使得 CPU 闲置。还有一些场景就是比如对于一个函数中的运算逻辑的性能问题，我们可以通过多线程的技术，使得一个函数中的多个逻辑运算通过多线程技术达到一个并行执行，从而提升性能，所以，多线程最终解决的就是“等待”的问题。

简单总结的使用场景
1）通过并行计算提高程序执行性能
2）需要等待网络、I/O 响应导致耗费大量的执行时间，可以采用异步线程的方式来减少阻塞。比如如果客户端只有一个线程，这个线程发起读取文件的操作必须等待IO 流返回，线程（客户端）才能做其他的事，那么我们可以使用多线程，一部分线程在等待 IO 操作返回，其他线程可以继续做其他的事。此时从客户端角度来说，客户端没有闲着。

2、如何应用多线程

在 Java 中，有多种方式来实现多线程。继承 Thread 类、实现 Runnable 接口、使用 ExecutorService、Callable、Future 实现带返回结果的多线程。
1）继承 Thread 类创建线程
Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个native 方法，它会启动一个新线程，并执行 run()方法。这种方式实现多线程很简单，通过自己的类直接 extend Thread，并复写 run()方法，就可以启动新线程并执行自己定义的 run()方法。

public class MyThread extends Thread { 
 	public void run() { 
 		System.out.println("MyThread.run()"); 
 	} 
}

MyThread myThread1 = new MyThread(); 
MyThread myThread2 = new MyThread(); 
myThread1.start(); 
myThread2.start(); 

2）实现 Runnable 接口创建线程
如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，可以实现一个 Runnable 接口

public class MyThread extends OtherClass implements Runnable { 
 	public void run() { 
 		System.out.println("MyThread.run()"); 
 	} 
} 

3）实现 Callable 接口通过 FutureTask 包装器来创建Thread 线程
有的时候，我们可能需要让一步执行的线程在执行完成以后，提供一个返回值给到当前的主线程，主线程需要依赖这个值进行后续的逻辑处理，那么这个时候，就需要用到带返回值的线程了。Java 中提供了这样的实现方式

public class CallableDemo implements Callable<String> {
	public static void main(String[] args) throws ExecutionException, 
		InterruptedException {
		ExecutorService executorService=
		Executors.newFixedThreadPool(1);
		CallableDemo callableDemo=new CallableDemo();
		Future<String> future=executorService.submit(callableDemo);
		System.out.println(future.get());
		executorService.shutdown();
	}
	
	@Override
	public String call() throws Exception {
		int a=1;
		int b=2;
		System.out.println(a+b);
		return "执行结果:"+(a+b);
	}
}

3、Java 并发编程的基础

线程作为操作系统调度的最小单元，并且能够让多线程同时执行，极大的提高了程序的性能，在多核环境下的优势更加明显。但是在使用多线程的过程中，如果对它的特性和原理不够理解的话，很容易造成各种问题。
线程的状态
Java 线程既然能够创建，那么也势必会被销毁，所以线程是存在生命周期的，那么我们接下来从线程的生命周期开始去了解线程。
线程一共有 6 种状态（NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED）

• NEW：初始状态，线程被构建，但是还没有调用 start 方法
• RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中”
• BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权，阻塞也分为几种情况
  Ø 等待阻塞：运行的线程执行 wait 方法，jvm 会把当前线程放入到等待队列
  Ø 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占用了，那么 jvm 会把当前的线程放入到锁池中
  Ø 其他阻塞：运行的线程执行 Thread.sleep 或者 t.join 方法，或者发出了 I/O请求时，JVM 会把当前线程设置为阻塞状态，当 sleep 结束、join 线程终止、io 处理完毕则线程恢复
• TIME_WAITING：超时等待状态，超时以后自动返回
• TERMINATED：终止状态，表示当前线程执行完毕

简单说一下join方法执行原理
原理如下：

注意：只有先开启了线程，在进行join才有效。
join方法测试

• 测试代码

package com.nrsc.ch1.base;

import com.nrsc.utils.SleepUtils;

public class JoinStudy {

    static class LiuNeng implements Runnable {

        public void run() {
            System.out.println("LiuNeng开始排队打饭.....");
            SleepUtils.second(2);//休眠2秒
            System.out.println(Thread.currentThread().getName()
                    + " LiuNeng打饭完成.");
        }
    }

    static class ZhaoSi implements Runnable {

        public void run() {
            SleepUtils.second(2);//休眠2秒
            System.out.println("ZhaoSi开始排队打饭.....");
            System.out.println(Thread.currentThread().getName()
                    + " ZhaoSi打饭完成.");
        }
    }

    public static void main(String[] args) throws Exception {
        //for (int i = 0; i < 3; i++) {
            //创建赵四线程
            ZhaoSi zhaoSi = new ZhaoSi();
            Thread zsThread = new Thread(zhaoSi);

            //创建刘能线程
            LiuNeng liuNeng = new LiuNeng();
            Thread lnThread = new Thread(liuNeng);

            //开启刘能线程
            lnThread.start();
            //刘能开始join --- 注意，只有先开启了线程，join才有效
            lnThread.join();

            //开启赵四线程，并join
            zsThread.start();
            zsThread.join();

            System.err.println("谢广坤开始排队打饭.....");
            SleepUtils.second(2);//让主线程休眠2秒
            System.err.println(Thread.currentThread().getName() + " 谢广坤打饭完成.");
        }
   // }
}

• 测试结果

4、守护线程

在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)
用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：
只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。
User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。
值得一提的是，守护线程并非只有虚拟机内部提供，用户在编写程序时也可以自己设置守护线程。下面的方法就是用来设置守护线程的。

Thread daemonTread = new Thread();
// 设定 daemonThread 为 守护线程，default false(非守护线程)
daemonThread.setDaemon(true);
// 验证当前线程是否为守护线程，返回 true 则为守护线程
daemonThread.isDaemon();

这里有几点需要注意：

(1) thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。
(2) 在Daemon线程中产生的新线程也是Daemon的。
(3) 不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑。

因为你不可能知道在所有的User完成之前，Daemon是否已经完成了预期的服务任务。一旦User退出了，可能大量数据还没有来得及读入或写出，计算任务也可能多次运行结果不一样。这对程序是毁灭性的。造成这个结果理由已经说过了：一旦所有User Thread离开了，虚拟机也就退出运行了。

//完成文件输出的守护线程任务
import java.io.*;
class TestRunnable implements Runnable{
	public void run(){
	　　try{
	　　　　Thread.sleep(1000);//守护线程阻塞1秒后运行
	　　　　File f=new File("daemon.txt");
	　　　　FileOutputStream os=new FileOutputStream(f,true);
	　　　　os.write("daemon".getBytes());
	　　}catch(IOException e1){
	　　　　e1.printStackTrace();
	　　}catch(InterruptedException e2){
	　　　　e2.printStackTrace();
	　　}
	}
}
 
public class TestDemo2{
	public static void main(String[] args) throws InterruptedException
	{
		Runnable tr=new TestRunnable();
		Thread thread=new Thread(tr);
		thread.setDaemon(true); //设置守护线程
		thread.start(); //开始执行分进程
	}
}

//运行结果：文件daemon.txt中没有"daemon"字符串。
看到了吧，把输入输出逻辑包装进守护线程多么的可怕，字符串并没有写入指定文件。原因也很简单，直到主线程完成，守护线程仍处于1秒的阻塞状态。这个时候主线程很快就运行完了，虚拟机退出，Daemon停止服务，输出操作自然失败了。

public class Test {
　　public static void main(String args) {
　　    Thread t1 = new MyCommon();
　　    Thread t2 = new Thread(new MyDaemon());
　　    t2.setDaemon(true); //设置为守护线程
　　    t2.start();
　　    t1.start();
　　}
}
 
class MyCommon extends Thread {
　　public void run() {
　　    for (int i = 0; i < 5; i++) {
　　        System.out.println("线程1第" + i + "次执行！");
　　        try {
　　            Thread.sleep(7);
　　        } catch (InterruptedException e) {
　　            e.printStackTrace();
　　        }
　　    }
　　}
}

class MyDaemon implements Runnable {
　　public void run() {
　　    for (long i = 0; i < 9999999L; i++) {
　　        System.out.println("后台线程第" + i + "次执行！");
　　        try {
　　            Thread.sleep(7);
　　        } catch (InterruptedException e) {
　　            e.printStackTrace();
　　        }
　　    }
　　}
}

运行结果

后台线程第0次执行！
线程1第0次执行！ 
线程1第1次执行！ 
后台线程第1次执行！ 
后台线程第2次执行！ 
线程1第2次执行！ 
线程1第3次执行！ 
后台线程第3次执行！ 
线程1第4次执行！ 
后台线程第4次执行！ 
后台线程第5次执行！ 
后台线程第6次执行！ 
后台线程第7次执行！ 
Process finished with exit code 0 

从上面的执行结果可以看出：
前台线程是保证执行完毕的，后台线程还没有执行完毕就退出了。
实际上：JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管后台线程的状态，因此，在使用后台县城时候一定要注意这个问题。
补充说明：

定义：守护线程–也称“服务线程”，在没有用户线程可服务时会自动离开。
优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。
设置：通过setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在 线程对象创建 之前 用线程对象的setDaemon方法。
example：垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的Thread,程序就不会再产生垃圾，垃圾回收器也就无事可做，所以当垃圾回收线程是JVM上仅剩的线程时，垃圾回收线程会自动离开。它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。
生命周期：守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。那Java的守护线程是什么样子的呢。当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则JVM不会退出。