Java多线程笔记全过程(一)

一、多线程最基础的基本概念

　　一个程序最少需要一个进程，而一个进程最少需要一个线程。

　　我们常说的高并发，也并不全是线程级别的并发，在很多开发语言中，比如PHP，很常见的都是进程级别的并发。但是在Java中谈论到的基本都是线程级别的并发。当然了，高并发的来源，与摩尔定律的概念相当，等单个人无法满足任务的需求时，找多个人一起干活。就成为了主流。

　　这里介绍几个多线程的概念：

　　1.1、进程和线程：

　　　　程序：开发写的代码称之为程序。程序是一组代码，是一组数据和指令集，当然了程序是一个静态的概念。　　　　

　　　　进程：将程序运行起来，称之为进程。进程存在生命周期，随着程序的终止而销毁。进程之间通过TCP/IP端口实现交互。

　　　　线程：线程是CPU调度和执行的最小单位。PS：很多多线程都是模拟出来的，真正的多线程是指多个CPU，也就是多核，如服务器。但是如果CPU只有一个，在同一个时间点内只会执行一个代码，但是由于计算机执行速度极快，导致产生同时执行的错觉。

　　1.2、并发、并行、串行

　　　　并行：多个任务同时进行，但是必须具备多核能力，才能实现。

　　　　并发：同一个对象被多个线程同时操作，这一种是假并发，一个CPU可以完成工作。

　　　　串行：一个程序处理完当前进程，按照顺序处理下一个进行，一个接着一个进行。

　　1.3、同步和异步：

　　　　同步：当进行方法调用时，必须等到方法调用返回后，才能够执行后续行为。例子：打电话、单线程。

　　　　异步：很像是消息传递，一旦开始，调用方法就会立刻返回，调用可以继续后续行为。例子：发短信、多线程。

　　1.4、临界区、死锁、活锁、饥饿：

　　　　临界区：一次被一个线程占用，其他线程必须排队，例子：办公室的打印机。注意：多线程情况下，共享资源必须上锁。

　　　　死锁：在唯一性的条件下，完成任务需要A、B，但是线程1拿着A，线程2拿着B，导致双方一直在等待，形成死循环。

　　　　活锁：经典例子：孔融让梨，虽然线程们都谦让资源，但是大家都没有办法使用资源，导致任务永远完不成。这种情况下，会耗费CPU的时间。

　　　　饥饿：当线程的优先级特别低的情况下，完成线程所需要的资源永远无法获取，会造成饥饿现象。

二、线程的创建以及启动

• 继承Thread类，并重写run()方法。

• 实现Runnable接口，并重写run()方法。

• 通过Callable和Future创建线程

　　2.1.1、继承Thread类

1、自定义线程类继承Thread类
2、重写run方法，编写线程执行体
3、创建线程对象，调用start()方法
注意：创建不代表执行，需要抢CPU资源

　　2.1.2、代码

public class A extends Thread {
    public A(String name){
        super(name);
    }
    @Override
    public void run(){
        // 线程执行体
        for (int i = 0; i < 10; i++) {
            System.out.println("我是自定义" + Thread.currentThread().getName() + "--" + i);
        }
    }
    public static void main(String[] args){
        // 创建线程对象，准备抢占资源
        A a1 = new A("线程1");
        A a2 = new A("线程2");
        a1.start();
        a2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是主线程--" + i);
        }
    }
}

　　2.2.1  实现Runnable接口

 1、自定义线程类实现Runnable接口
 2、重写run方法，编写线程执行体
 3、创建线程对象，调用start()方法
 注意：创建不代表执行，需要抢CPU资源

　　2.2.2 代码

public class A implements Runnable  {

    @Override
    public void run(){
        // 线程执行体
        for (int i = 0; i < 10; i++) {
            System.out.println("我是自定义" + Thread.currentThread().getName() + "--" + i);
        }
    }
    public static void main(String[] args){
        // 创建线程对象，准备抢占资源
        // 创建实现类对象
        A myRunnable = new A();
        Thread t1 = new Thread(myRunnable,"线程1");
        Thread t2 = new Thread(myRunnable,"线程2");
        t1.start();
        t2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("我是主线程--" + i);
        }
    }

}

　　2.3.1   实现Callable接口（不常用）

1、实现Callable接口，先要返回值类型
2、重写call()方法，需要抛出异常
3、创建目标对象
4、创建执行服务：ExecutorService ser = Executor.newFixedThreadPool(1);
5、提交执行：Future<Boolean> res = ser.submit(t1);
6、获取结果：boolean r1 = res.get();
7、关闭服务：ser.shutdownNow();

　　2.3.2   代码

import java.util.concurrent.*;

// 自定义线程对象，实现Callable接口，重写call()方法
public class A implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        // 线程执行体
        for (int i = 0; i < 10; i++) {
            System.out.println("我是自定义" + Thread.currentThread().getName() + "--" + i);
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException,
            InterruptedException {
        // main线程，主线程
        // 创建线程实现类对象
        A thread = new A();
        A thread2 = new A();
        // 创建执行服务，参数是线程池线程数量
        ExecutorService ser = Executors.newFixedThreadPool(2);
        // 提交执行
        Future<Boolean> res = ser.submit(thread);
        Future<Boolean> res2 = ser.submit(thread2);
        // 获取结果
        boolean r1 = res.get();
        boolean r2 = res2.get();
        // 关闭服务
        ser.shutdownNow();
    }
}

三、线程的生命周期

　　新建（New）状态： 创建后尚未启动（未调用start()方法）的线程处于这种状态。

　　就绪（Ready）状态： 当调用线程对象的start()方法，线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行。

　　运行（Running）状态： 当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。

　　限期等待（Timed Waiting）状态： 处于这种状态的线程也不会被分配CPU执行时间，不过无须等待其他线程显式地唤醒，在一定时间之后它们会由系统自动唤醒。以下方法会让线程进入限期等待状态：

　　新建无限期等待（Waiting）状态： 处于这种状态的线程不会被分配CPU执行时间，它们要等待被其他线程显式地唤醒。以下方法会让线程陷入无限期的等待状态。

　　阻塞（Blocked）状态： 线程在获取synchronized排他锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。

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