Java多线程| 01 | 线程概述

线程相关概念

进程与线程

进程：进程(Process)是计算机中的程序关于某数据集合上的一次运行活动，是操作系统进行资源分配与调度的基本单位。可以把进程简单的理解为正在操作系统中运行的一个程序.
线程：线程(thread)是进程的一个执行单元。一个线程就是进程中一个单一顺序的控制流，进程的一个执行分支进程是线程的容器，一个进程至少有一个线程。一个进程中也可以有多个线程

在操作系统中是以进程为单位分配资源，如虚拟存储空间，文件描述符等.每个线程都有各自的线程栈，自己的寄存器环境，自己的线程本地存储。

主线程与子线程

JVM启动时会创建一个主线程，该主线程负责执行main方法，主线程就是运行main方法的线程。Java中的线程不是孤立的，线程之间存在一些联系，如果在A线程中创建了B线程，称B线程为A线程的子线程，相应的A线程就是B线程的父线程

串行、并行与并发

并发可以提高事物的处理效率，即一段时间内可以处理或者完成更多的事情。并行是一种更为严格，理想的并发从硬件角度来说，如果单核CPU，一个处理器一次只能执行一个线程的情况下，处理器可以使用时间片轮转技术，可以让CPU快速的在各个线程之间进行切换，对于用来来说，感觉是三个线程在同时执行。如果是多核心CPU，可以为不同的线程分配不同的CPU内核。

原子性、可见性、有序性

　在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。我们先看具体看一下这三个概念：

1.原子性

　　原子性：即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

　　一个很经典的例子就是银行账户转账问题：

　　比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。

　　试想一下，如果这2个操作不具备原子性，会造成什么样的后果。假如从账户A减去1000元之后，操作突然中止。然后又从B取出了500元，取出500元之后，再执行往账户B加上1000元的操作。这样就会导致账户A虽然减去了1000元，但是账户B没有收到这个转过来的1000元。

　　所以这2个操作必须要具备原子性才能保证不出现一些意外的问题。

　　同样地反映到并发编程中会出现什么结果呢？

　　举个最简单的例子，大家想一下假如为一个32位的变量赋值过程不具备原子性的话，会发生什么后果？

i = 9;

　假若一个线程执行到这个语句时，我暂且假设为一个32位的变量赋值包括两个过程：为低16位赋值，为高16位赋值。

　　那么就可能发生一种情况：当将低16位数值写入之后，突然被中断，而此时又有一个线程去读取i的值，那么读取到的就是错误的数据。

2.可见性

　　可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

　　举个简单的例子，看下面这段代码：

//线程1执行的代码
int i = 0;
i = 10;//线程2执行的代码
j = i;

　假若执行线程1的是CPU1，执行线程2的是CPU2。由上面的分析可知，当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。

　　此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.

　　这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

3.有序性

　　有序性：即程序执行的顺序按照代码的先后顺序执行。举个简单的例子，看下面这段代码：

int i = 0;
boolean flag = false;
i = 1;                //语句1
flag = true;          //语句2

　上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序（Instruction Reorder）。

　　下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

　　比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

　　但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？再看下面一个例子：

int a = 10;    //语句1
int r = 2;    //语句2
a = a + 3;    //语句3
r = a*a;     //语句4

　这段代码有4个语句，那么可能的一个执行顺序是：

　　那么可不可能是这个执行顺序呢：语句2 语句1 语句4 语句3

　　不可能，因为处理器在进行重排序时是会考虑指令之间的数据依赖性，如果一个指令Instruction 2必须用到Instruction 1的结果，那么处理器会保证Instruction 1会在Instruction 2之前执行。

　　虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：

//线程1:
context = loadContext();   //语句1
inited = true;             //语句2//线程2:
while(!inited ){
  sleep()
}
doSomethingwithconfig(context);

　上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。

　从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

　　也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

线程常用方法

currentThread()

Thread.currentThread()方法可以获得当前线程。

Java中的任何一段代码都是执行在某个线程当中的，执行当前代码的线程就是当前线程，同一段代码可能被不同的线程执行，因此当前线程是相对的，Thread.currentThread()方法的返回值是在代码实际运行时候的线程对象

public class SubThread extends Thread{
    public SubThread(){
        System.out.println("构造方法中，Thread.currentThread().getName():"+Thread.currentThread().getName());
        System.out.println("构造方法，this.getName():"+this.getName());
    }    @Override
    public void run() {
        System.out.println("run方法中，Thread.currentThread().getName():"+Thread.currentThread().getName());
        System.out.println("run方法，this.getName():"+this.getName());
    }
}  public static void main(String[] args) throws InterruptedException {
        SubThread t2 = new SubThread();
        t2.setName("t2");
        //设置线程的名称
         t2.start();
         Thread.sleep(500); //main线程睡眠500毫秒
        //Thread(Runnable) 构造方法形参是Runnable接口，调用时传递的实参是接口的实现类对象
         Thread t3 = new Thread(t2);
         t3.start();
    }

输出结果

构造方法中，Thread.currentThread().getName():main
构造方法，this.getName():Thread-0
run方法中，Thread.currentThread().getName():t2
run方法，this.getName():t2
run方法中，Thread.currentThread().getName():Thread-1
run方法，this.getName():t2

setName()/getName()

thread.setName(线程名称)，设置线程名称。

thread.getName()，返回线程名称。

通过设置线程名称，有助于程序调试，提高程序的可读性，建议为每个线程都设置一个能够体现线程功能的名称

isAlive()

thread.isAlive() 判断当前线程是否处于活动状态活动状态就是线程已启动并且尚未终止

 public void testIsAlive(){
        SubThread subThread = new SubThread();
        System.out.println("begin==" + subThread.isAlive()); //false，在启动线程之前
        subThread.run();
      //结果不一定，打印这一行时，如果subThread线程还没结束就返回true，如果线程已结束，返回false
        System.out.println("end==" + subThread.isAlive());
    }

返回结果：

构造方法中，Thread.currentThread().getName():main
构造方法，this.getName():Thread-0
begin==false
run方法中，Thread.currentThread().getName():main
run方法，this.getName():Thread-0
end==false

sleep()

Thread.sleep(millis);

让当前线程休眠指定的毫秒数，当前线程是指Thread.currentThread()返回的线程

public void testSleep(){
        try {
            SubThread t3 = new SubThread();
            System.out.println("main__begin=" + System.currentTimeMillis());
//        t3.start();     //开启新线程
            t3.run();       //在main线程中调用实例方法run()，没有开启新的线程
            Thread.sleep(2000);
            System.out.println("main__end=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }    }

start()会开启新的线程，run()不会开启新的线程

在子线程的run方法中，如果有受检异常(编译时异常)需要处理，只有选择捕获处理，不能抛出处理

getId()

thread.getId()可以获得线程的唯一标识

某个编号的线程运行结束后，该编号可能被后续创建的线程使用重启的JVM后，同一个线程的编号可能不一样

yield()

Thread.yield()方法的作用是放弃当前的CPU资源

setPriority()

thread.setPriority(num)设置线程的优先级java线程的优先级取值范围是1~10，如果超出这个范围会抛出异常IllegalArgumentException。在操作系统中，优先级较高的线程获得CPU的资源越多线程优先级本质上是只是给线程调度器一个提示信息，以便于调度器决定先调度哪些线程。注意不能保证优先级高的线程先运行。

Java优先级设置不当或者滥用可能会导致某些线程永远无法得到运行，即产生了线程饥饿。线程的优先级并不是设置的越高越好，一般情况下使用普通的优先级即可，即在开发时不必设置线程的优先级线程的优先级具有继承性，在A线程中创建了B线程，则B线程的优先级与A线程是一样的。

interrupt()

中断线程。注意调用interrupt()方法仅仅是在当前线程打一个停止标志，并不是真正的停止线程

isInterrupted()方法，该方法返回线程的中断标志

setDaemon()

Java中的线程分为用户线程与守护线程。它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

守护线程是为其他线程提供服务的线程，如垃圾回收器(GC)就是一个典型的守护线程，守护线程不能单独运行，当JVM中没有其他用户线程，只有守护线程时，守护线程会自动销毁，JVM会退出。

在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程

若JVM中都是守护线程，当前JVM将退出

用户进程结束后守护线程不会立马销毁，还会执行一段时间再销毁

public class DaemonThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("守护线程运行");
        }
    }
}
@Test
    public void testDae(){
        DaemonThread daemonThread = new DaemonThread();
        daemonThread.setDaemon(true);
        daemonThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main==" + i);
        }
        System.out.println("用户进程结束");
    }

运行结果

main==0
main==1
main==2
main==3
main==4
main==5
main==6
main==7
main==8
main==9
用户进程结束
守护线程运行
守护线程运行
守护线程运行
守护线程运行
守护线程运行
守护线程运行
守护线程运行
守护线程运行
守护线程运行

线程的生命周期

线程的状态线程生命周期可以通过getState()方法获得，线程的状态是Thread.State枚举类型定义的，由以下几种:

NEW，新建状态，创建了线程对象，在调用start()启动之前的状态
RUNNABLE，可运行状态。它是一个复合状态
- READY状态，该线程可以被线程调度器进行调度使它处于RUNNING状态，
- RUNING状态，表示该线程正在执行。Thread.yield()方法可以把线程由RUNNING状态转换为READY状态
BLOCKED阻塞状态。线程发起阻塞的I/O操作，或者申请由其他线程占用的独占资源，线程会转换为BLOCKED阻塞状态。处于阻塞状态的线程不会占用CPU资源，当阻塞I/O操作执行完，或者线程获得了其申请的资源，线程可以转换为RUNNABLE。

一个线程因为等待临界区的锁被阻塞产生的状态，Lock 或者synchronize 关键字产生的状态
WAITING等待状态，线程执行了object.wait()或thread.join()方法把线程转换为WAITING等待状态，执行object.notify()方法，或者线程执行完毕，当前线程会转换为RUNNABLE状态

一个线程进入了锁，但是需要等待其他线程执行某些操作。时间不确定
TIMED_WAITING状态，与WAITING状态类似，都是等待状态.区别在于处于该状态的线程不会无限的等待，如果线程没有在指定的时间范围内完成期望的操作，该线程自动转换为RUNNABLETERMINATED终止状态，线程结束处于终止状态

多线程编程的优势与风险

多线程编程具有以下优势:

提高系统的吞吐率(Throughout)。多线程编程可以使一个进程有多个并发(concurrent,即同时进行的)的操作
提高响应性(Responsiveness)。Web服务器会采用一些专门的线程负责用户的请求处理,缩短了用户的等待时间
充分利用多核(Multicore)处理器资源.通过多线程可以充分的利用CPU资源

多线程编程存在的问题与风险:

线程安全(Threadsafe)问题。多线程共享数据时，如果没有采取正确的并发访问控制措施，就可能会产生数据一致性问题,如读取脏数据(过期的数据)，如丢失数据更新
线程活性(threadliveness)问题。由于程序自身的缺陷或者由资源稀缺性导致线程一直处于非RUNNABLE状态，这就是线程活性问题,常见的活性故障有以下几种:
- 死锁(Deadlock).类似鹬蚌相争
- 锁死(Lockout),类似于睡美人故事中王子挂了
- 活锁(Livelock).类似于小猫咬自己尾巴(4)
- 饥饿(Starvation).类似于健壮的雏鸟总是从母鸟嘴中抢到食物.