java并发编程(一)——进程与线程

基本概念

进程：进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。

一个应用程序至少对应着一个进程，对于一些应用程序，如浏览器或者QQ，允许启动多个同一应用程序，会对应多个进程。

每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是系统资源分配和调度的最小单位）

线程：线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。如360安全卫士可以同时进行病毒查杀、加速、电脑清理等不同的子任务，每一个子任务都对应着一个线程。一个应用程序运行起来之后，一定会首先创建一个首要线程-，称作主线程。

一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源（进程是系统资源分配和调度的最小单位）。它与父进程的其他线程共享该进程的堆和方法区资源。

线程是cpu调度的最小单位，是比进程更小的独立运行的单位。线程之间切换的开销小，所以线程也称为轻量级进程。

堆和方法区是所有线程共享的资源，其中堆是进程中最大的一块内存，主要用于存放新创建的对象 (几乎所有对象都在这里分配内存)，方法区主要用于存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

进程与线程的区别：

1、线程和进程最大的不同在于各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。

2、一个进程中可以有多个线程，多个线程共享进程的堆和方法区资源，但是每个线程有自己的程序计数器、虚拟机栈和本地方法栈。

3、进程切换时消耗的资源大，线程切换消耗的资源较小。

4、进程是系统资源分配和调度的最小单位，线程是CPU调度的最小单位。

线程的创建

java中创建线程有两种方式，一种是继承Thread类，第二种是实现Runnable接口。继承Thread类是将线程和任务合在一起，实现Runable接口是将线程和任务分开。

/**继承Thread类
 * 1、创建一个类继承Thread类，重写run方法，run方法中的内容即是线程需要执行的任务
 * 2、创建子类的实例，即创建了一个线程对象
 * 3、调用该线程对象的start方法启动线程，会使线程执行run方法中的内容
 */

public class MyThread extends Thread{
    @Override
    public void run(){
        for (int a=0; a<5; a++){
            System.out.println("thread=========");
        }
    }

    public static void main(String args[]){
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

/**实现Runnable接口
 * 1、创建一个类实现Runnable接口，重写run方法
 * 2、将之前Runnable的实现类的对象作为参数，创建一个Thread类，该Thread类即为线程对象
 * 3.调用线程对象的start方法启动线程，就会让线层执行run方法中的内容
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int a=0; a<5; a++){
            System.out.println("thread=========");
        }
    }

    public static void main(String args[]){
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

/**
 * 通过匿名内部类创建线程
 */
public class Test extends Thread{

    public static void main(String args[]){
        
        new Thread(){
            @Override
            public void run(){
                System.out.println("=========");
            }
        }.start();
        
        //其实是向上转型，实质是 Runnable runnable = new RunnableImpl();
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                System.out.println("=========");
            }
        };
        new Thread(runnable).start();
    }
}

/**使用Lambda创建线程，其实就是简化代码
 * Lambda表达式的标准格式有三部分给组成
 *  1、一些参数，用()括起来
 *  2、一个箭头，传递的意思，把前面的参数传递个后面的代码
 *  3、一段代码，用{}括起来的代码块，重写接口抽象方法的方法体
 * */

public class LambdaTest {

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类创建线程");
            }
        }).start();

        //使用Lambda表达式
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "正在执行");
        }).start();
    }
}

实现Runnable接口比继承Thread类所具有的优势：

1、适合多个相同的程序代码的线程去处理同一个资源

2、可以避免java中的单继承的限制

3、增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

4、线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

线程中的常用方法

1、void start()，该方法使线程处于可执行状态，但不一定马上执行，需要和其他线程一起抢占CPU资源。

2、String getName()，通过该方法可以获取线程的名字，该方法返回值为String。mt.getName()，获取线程mt的名字。默认主线程的名字是main，其他线程的名字是Thread-0，Thread-1，Thread-2，。。。。

3、void setName(String name)，设置线程名称，该方法返回值为void。mt.setName("myThread")，设置线程名称为myThread。

4、static Thread currentThread()，通过该方法可以获取当前CPU执行的是哪个线程，这是Thread类的一个静态方法，该方法返回值为Thread。Thread.currentThread()。

5、static void sleep(long millis)，使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），这是一个静态方法，返回值为void。Thread.sleep(100)，是当前线程暂停100毫秒

6、void join()，join()方法的作用是等待该线程结束（正常执行完或者异常结束），如果在b线程里面使用a.join()，可以理解为将a线程加入b线程，这样b线程执行的时候就只能等a线程执行完。该方法可以设置最多等待多少毫秒，join(1000)，最多等待1000毫秒。

class JoinTest {
    public static void main(String[] args) {
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName() + "开始执行");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread a = new Thread(()->{
                try {
                    System.out.println(Thread.currentThread().getName() + "开始执行");
                    Thread.sleep(2000);
                    System.out.println(Thread.currentThread().getName() + "执行结束");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"线程2");
            a.start();
            try {
                a.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "执行结束");
        },"线程1").start();
    }
}

/**运行结果
 * 线程1开始执行
 * 线程2开始执行
 * 线程2执行结束
 * 线程1执行结束
 * */

7、static void yield()，暂停当前线程，使其让出当前正在使用的处理器回到可执行状态。需要注意的是，即使线程调用了yield()，让出了正在使用的处理器，该线程还是会和其他同一优先级的线程再次抢占CPU资源，也就是说有可能该线程执行了yield()后会再次执行。sleep()会使线程进入不可执行状态，指定毫秒数内不执行，而yield()不一定会使线程停止执行。

8、void interrupt()，中断一个线程，该方法通常会与isInterrupted()配合使用。注意，中断使用了sleep，wait，join这类阻塞状态的线程，isInterrupted()的返回值是false，而中断正常运行的线程，isInterrupted()的返回值为true，通过判断返回值来确定是否确实要中断该进程。

守护线程

java程序启动时，第一个创建的线程是主线程，之后再创建其他的线程，只要还有一个线程没有结束，这个java应用程序对应的进程就不会结束，即使主线程已经结束了。如果将一个线程设置为守护线程，那么当其他的非守护线程执行完后，不论该守护线程是否执行完毕，都会强制结束。使用 t.setDaemon(true) 将线程t设置为守护线程。

垃圾回收器线程就是一个守护线程

线程的生命周期

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。尤其是当线程启动以后，它不可能一直"霸占"着 CPU 独自运行，所以 CPU 需要在多条线程之间切换，于是线程状态也会多个状态之间切换。

线程的五种状态——从操作系统角度描述

在线程的生命周期中，它要经过新建状态(New)、就绪状态（Runnable）、运行状态（Running）、阻塞状态(Blocked)和死亡(Dead) 这 5 种状态。

新建状态（New）：当程序使用 new 关键字创建了一个线程对象后，该线程就处于新建状态，此时仅由 JVM 为其分配内存，并初始化其成员变量的值。

就绪状态（Runnable）：当线程对象调用了 start()方法之后，该线程处于就绪状态。Java 虚拟机会为其创建方法调用栈和程序计数器，等待调度运行。

运行状态（Running）：如果处于就绪状态的线程获得了 CPU，开始执行 run()方法的线程执行体，则该线程处于运行状态。

阻塞状态（Blocked）：阻塞状态是指线程因为某种原因放弃了 cpu 使用权，暂时停止运行。直到线程进入可运行状态(runnable)，才有机会再次获得 cpu 时间片转到运行状态(running)。阻塞状态分为三种：

1、等待阻塞：运行的线程执行wait()方法，JVM 会把该线程放入等待队列(waitting queue)中。(wait会释放持有的锁)

2、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池(lock pool)中。

3、其他阻塞：运行的线程执行sleep()方法或 join()方法，或者发出了 I/O 请求时，JVM 会把该线程置为阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O处理完毕时，线程重新转入可运行(runnable)状态。（sleep不会释放持有的锁）

死亡状态（Dead）：线程执行完后正常结束或者因异常退出了run()方法，该线程结束生命周期。

线程的六种状态——从java API层面描述

从java API角度来描述线程可以分为六种状态，新建状态（NEW），运行状态（RUNNABLE），等待状态（WAITING），超时等待（TIMED_WAIING），阻塞状态（BLOCKED），终止状态（TERMINATED）。这六种状态的划分其实是根据类Thread.state枚举得到的。注意：这里的RUNNABLE状态包括了操作系统层面的就绪状态和运行状态，甚至还包括了某些原因引起的阻塞状态（如BIO导致的线程阻塞在java中无法区分，仍然认为是可运行状态）.。BLOCKED、WAITING、TIMED_WAIING都是java API对操作系统阻塞状态的细分。