多线程

进程概念

进程是指正在运行的程序；

确切的来说是，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并具有一定独立功能；

线程概念

线程是进程中的一个执行单元（执行路径），负责当前进程中程序的执行；

一个进程中至少有一个线程；

一个进程中有多个线程，这个应用程序可以称之为多线程程序；

多线程概念

一个程序中有多个线程在同时执行，就是多线程；

一个核心的CPU在多个线程之间进行着随机切换动作，由于切换动作时间很短（毫秒甚至纳秒级别），导致我们感觉不出来；

• 线程程序：即若有多个任务，只能依次执行；当上一个任务执行结束后，下一个任务才开始执行；比如去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能去上网；
• 多线程程序：即若有多个任务，可以同时执行；比如去网吧上网，网吧能够让多个人同时上网；

线程的运行模式

• 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间；
• 抢占式调度：抢占让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性）；java使用的是抢占式调度；

大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：上课时一边使用编辑器，一边使用录屏软件，同时还开着画图板、dos窗口等软件。此时这些程序是在同时运行，“感觉这些软件好像在同一时刻运行着”。

实际上，cpu（中央处理器）使用抢占式调度模式在多个线程之间进行着高速的切换。对于cpu的一个核而言，某个时刻只能执行一个线程，而cpu在多个线程间切换的速度相对于我们的感觉要快，看上去实在同一时刻运行。

其实多线程程序并不能提高程序的运行速度，但能够提高程序的运行效率，让cpu的使用率更高。

Thread类

Thread是程序中的执行线程；Java虚拟机允许应用程序并发地运行多个执行线程；

构造方法：

• Thread() 分配新的Thread对象；
• Thread(String name) 分配新的Thread对象，将指定的name作为其线程名称；

常用方法：

• void start() 使用该线程开始执行，java虚拟机调用该线程的run方法；
• void run 该线程要执行的操作，
• static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）；

创建新执行线程有两种方法：

1. 一种方法是：将类声明为Thread的子类；该子类应重写Thread类的run方法，创建对象，开启线程；run方法相当于其他线程的main方法；
2. 另一方法是：声明一个实现Runnable接口的类，然后该类实现run方法，然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程；

创建线程方式------继承Thread类

/**
 * 1. 定义一个类继承Thread
 * 2. 重写run方法
 * 3. 创建子类对象，就是创建线程对象
 * 4. 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法
 */
public static void main(String[] args) {
    //创建自定义线程对象
    MyThread myThread = new MyThread("新的线程");
    //开启新线程
    myThread.start();
    //在主方法中执行for循环
    for (int i = 0; i < 5; i++) {
        System.out.println("main线程" + i);
    }
}
public class MyThread extends Thread {
    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }
    //重写run方法，完成该线程执行的逻辑
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + ": 正在执行" + i);
        }
    }
}
输出：（顺序随机）
新的线程: 正在执行0
main线程0
新的线程: 正在执行1
main线程1
新的线程: 正在执行2
main线程2
新的线程: 正在执行3
main线程3
新的线程: 正在执行4
main线程4

线程对象调用run方法不开启线程，线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行；

继承Thread类原理

创建线程的目的是为了建立程序单独的执行路径，让多部分代码实现同时执行，也就是说线程创建并执行需要给定线程要执行的任务；

主线程的任务定义在main方法中，自定义线程需要执行的任务都定义在run方法中。

Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可，所以进行了重写run方法动作；

多线程的内存图解

以上个程序为例图解说明；多线程执行时，在栈内存中，其实每个执行线程都有一片自己所属的栈内存空间，进行方法的压栈盒弹栈；

多线程内存图解.png

当执行线程的任务结束了，线程自动在栈内存中释放了，但是当所有的执行线程都结束了，那么进程久结束了；

获取线程名字------Thread类方法getName()、currentThread()

每个线程都有自己的名字，运行main方法，名字就是main；

其他新建的线程也有名字，默认"Thread-0"，"Thread-1"...

JVM开启主线程，运行方法main，主线程也是线程，是线程就必然是Thread类对象；

• String getName() 返回该线程的名称；
• static Thread currentThread() 返回当前正在执行的线程对象的引用；

public static void main(String[] args) {
    MyThread myThread1 = new MyThread();
    MyThread myThread2 = new MyThread("testName");
    myThread1.start();
    myThread2.start();
    System.out.println(Thread.currentThread().getName());
}
public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(getName());
    }
}
输出：(顺序随机)
Thread-0
main
testName

Thread类方法sleep

• static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）；

public class SleepThread extends Thread {
    public SleepThread (String name) {
        super(name);
    }
    @Override
    public void run () {
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);//睡眠1秒，1秒到后cpu切换到该线程继续往下执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getName() + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        SleepThread st = new SleepThread("sleepThread");
        st.start();
    }
}

创建线程方式------实现Runnable接口

创建线程的另一种方法是声明实现Runnable接口的类，然后该类实现run方法，然后创建Runnable的实现类对象，传入到某个线程的构造方法中，开启线程；

Runnable接口是用来指定每个线程要执行的任务，包含了一个run的无参数抽象方法，需要由接口实现类重写该方法；

构造方法：

• Thread(Runnable target) 分配新的Thread对象，以便将target作为其对象；
• Thread(Runnable target, String name) 分配新的Thread对象，以便将target作为其运行对象，将指定的name作为其名称；

方法：

• void run() 使用实现接口Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run方法；

  创建

/**
 * 创建线程步骤：
 * 1. 定义类实现Runnable接口
 * 2. 重写接口中的run方法
 * 3. 创建Thread类对象
 * 4. 将Runnable接口的子类对象作为参数传递给Thread类的构造函数
 * 5. 调用Thread类的start方法开启线程
 */
public static void main(String[] args) {
    //创建线程执行目标类对象
    Runnable runnable = new MyRunnable();
    //将Runnable接口的子类对象作为参数传递给Thread类的构造方法
    Thread thread = new Thread(runnable);
    //开启线程
    thread.start();
    for (int i = 0; i < 10; i++) {
        System.out.println("main线程正在执行" + i);
    }
}
public class MyRunnable implements Runnable {
    //定义线程要执行的run方法逻辑
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我的线程正在执行" + i);
        }
    }
}

实现Runnable的原理

实现Runnable接口，避免了继承Thread类的单继承局限性，重写Runnable接口中的run方法，将线程任务代码定义到run方法中；

只有创建Thread类的对象才可以创建线程，线程任务已被封装到Runnable接口的run方法中，而这个run方法属于Runnable接口的实现类对象，所以将这个实现类对象作为参数传递给Thread的构造放啊，这样线程对象创建时就可以明确要运行的线程的任务；

实现Runnable接口方式的好处

这种方式避免了单继承的局限性，较为常用；

这种方式更加符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务；

继承Thread类，线程对象和线程任务是耦合在一起的，一旦创建Thread的子类对象，既是线程对象，又是线程任务；

实现Runnable接口，将线程任务和单独分离出来封装成对象，类型就是Runnable接口类型；Runnable接口对线程对象和线程任务进行解耦；（降低紧密型或依赖性，创建线程和执行任务不绑定）；

匿名内部类实现线程程序

/**
 * 继承方式 xxx extends Thread {public void run() {} }
 */
new Thread() {
    @Override
    public void run() {
        System.out.println("继承方式");
    }
}.start();

/**
 * 实现接口方式1 XXX implements Runnable { public void run() {}}
 */
Runnable runnable1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("实现接口方式1");
    }
};
new Thread(runnable1).start();

/**
 * 实现接口方式2
 */
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("实现接口方式2");
    }
}).start();

---

线程池

线程池概念

线程池就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源；

线程池.png

在java中，如果每个请求到达就创建一个新线程，这个开销是非常大的；

实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源还要多；

除了创建和销毁线程的开销外，活动的线程也需要消耗系统的资源；

如果在一个jvm例创建太多的线程，可能会是系统由于过度消耗内存，或“切换过度”而导致系统资源不足；

为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源消耗比较大的线程的创建和销毁，尽量利用已有对象来进行服务；

线程池主要用来解决线程生命周期开销问题和资源不足问题；通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟，这样就可以立即为请求服务，使应用程序的响应更快；

另外，通过适当调整线程池中的线程数目，可以防止出现资源不足的情况；

使用线程池方式------Runnable接口

通常线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法；

• Executors：线程池创建工厂类；使用工厂类Executors中的静态方法创建线程对象，指定线程的个数，

• public static ExecutorService newFixedThreadPool(int nThreads) 返回线程池对象，指定线程的个数；

• ExecutorService：线程池类；接口实现类对象，调用方法submit(Runnable r)提交线程执行任务；

• Future<?> submit(Runnable task) 获取线程池中的某一个线程对象，并执行；

• Future接口：用来记录线程任务执行完毕后产生的结果，线程池创建与使用；

使用线程池中线程对象的步骤：

1. 创建线程池对象；
2. 创建Runnable接口实现类对象；
3. 提交Runnable接口实现类对象；
4. 关闭线程池；

public class Demo {
    public static void main(String[] args) {
        //调用工厂类的静态方法创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);
        //创建Runnable实例对象
        MyRunnable myRunnable = new MyRunnable();

        //从线程池中获取线程对象，然后调用MyRunnable中的run()
        service.submit(myRunnable);
        service.submit(myRunnable);
        //submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭，并将使用完的线程又归还到了线程池中
        //关闭线程池
        service.shutdown();
    }
}
public class MyRunnable implements Runnable {
    //定义线程要执行的run方法逻辑
    @Override
    public void run() {
        System.out.println("I implements a runnable");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName());
        System.out.println("implemented");
    }
}
输出：（随机输出）
I implements a runnable
I implements a runnable
pool-1-thread-1
implemented
pool-1-thread-2
implemented

使用线程池方式------Callable接口

• Callable接口：与Runnable接口功能相似，用来指定线程的任务，其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常；

• ExecutorService：线程池类；

• <T>Future<T>submit(Callable<T> task) 获取线程池中的某一个线程对象，并执行线程中的call()方法；

• Future接口：用来记录线程任务执行完毕后产生的结果，线程池创建与使用；

• V get() 获取Future对象中封装的数据结果；

• 使用线程池中线程对象的步骤：

  1. 创建线程池对象；
  2. 创建Callable接口实现类对象；
  3. 提交Callable接口实现类对象；
  4. 关闭线程池；
  

public class Demo {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);
        //创建Callable对象
        MyCallable myCallable = new MyCallable();
        //从线程池中获取对象，然后调用MyCallable中的call()
        service.submit(myCallable);
        service.submit(myCallable);
        //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中
        //关闭线程池
        service.shutdown();
    }
}
public class MyCallable implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("my callable call");
        Thread.sleep(2000);
        System.out.println("callable: " + Thread.currentThread().getName());
        return null;
    }
}

线程实现异步计算

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(2);
        Future<Integer> f1 = service.submit(new GetSumCallable(100));
        Future<Integer> f2 = service.submit(new GetSumCallable(200));
        //V get()获取Future对象中封装的数据结果
        System.out.println(f1.get());
        System.out.println(f2.get());
        service.shutdown();
    }
}
public class GetSumCallable implements Callable<Integer> {
    private int a;
    public GetSumCallable() {}
    public GetSumCallable(int a) {
        this.a = a;
    }
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= a; i++) {
            sum += i;
        }
        return sum;
    }
}

---

线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行一段代码，程序每次运行结果喝单线程运行的结果是一样的，而其他变量的值也和预期一样，就是线程安全的

其实线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说这个全局变量是线程安全的；若有多个线程同时执行写操作，一般需要考虑线程同步，否则的话就可能影响安全；

线程同步（线程安全处理Synchronized）

java中提供了线程同步机制，它能够解决线程安全问题；

线程同步的方式有两种：

1. 方式一：同步代码块；
2. 方式二：同步方法；

同步代码块

同步代码块，在代码块声明上，加上synchronized

synchronized (锁对象) {
    可能会产生线程安全问题的代码；
}

同步代码块中的锁对象可以是任意的对象，但多个线程时，要使用同一个锁对象才能够保证线程安全；

public class Ticket implements Runnable{
    int ticket = 100;
    //定义锁对象
    Object lock = new Object();

    @Override
    public void run() {
        //模拟卖票
        while (true) {
            //同步代码块
            synchronized (lock) {
                if (ticket > 0) {
                    //模拟电影选座的操作
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖票: " + ticket--);
                }
            }
        }
    }
}

同步方法

• 在方法声明上加上synchronized;
• 好处是代码简洁；

public synchronized void method() {
    //可能会产生线程安全问题的代码
}

同步方法中的锁对象是this；

public class Ticket implements Runnable{
    int ticket = 100;
    @Override
    public void run() {
        //模拟卖票
        while (true) {
            //同步方法
            method();
        }
    }
    //同步方法，锁对象this
    public synchronized void method() {
        if (ticket > 0) {
            //模拟电影选座的操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖票: " + ticket--);
        }
    }
}

• 静态同步方法，在方法声明上加上static synchronized;

public static synchronized void method() {
  //可能会产生线程安全问题的代码
}

静态同步方法中的锁对象是类名.class;

JDK特性Lock接口

Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作；

• void lock() 获取锁；
• void unlock() 释放锁；

Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能；

死锁

同步锁使用的弊端：当线程任务中出现了多个同步（多个锁）时，如果同步中嵌套了其他的同步，这时容易引发一种现象：程序出现无限等待，这种现象称为死锁；这种情况需要避免；

synchronzied(A锁){
    synchronized(B锁){

    }
}

线程的思锁代码实现：

public class Demo {
    public static void main(String[] args) {
        //创建线程任务类对象
        ThreadTask task = new ThreadTask();
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        //启动线程
        thread1.start();
        thread2.start();
    }
}
//线程任务类
public class ThreadTask implements Runnable {
    int x = new Random().nextInt(1);
    //指定线程要执行的任务代码
    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
                synchronized (MyLock.lockA) {
                    System.out.println("if-LockA");
                    synchronized (MyLock.lockB) {
                        System.out.println("if-LockB");
                    }
                }
            } else {
                synchronized (MyLock.lockB) {
                    System.out.println("else-LockB");
                    synchronized (MyLock.lockA) {
                        System.out.println("else-LockA");
                    }
                }
            }
            x++;
        }
    }
}
//定义锁对象类
public class MyLock {
    public static final Object lockA = new Object();
    public static final Object lockB = new Object();
}

等待唤醒机制

线程直接的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同，通过一定的手段使各个线程能有效的利用资源，而这种手段即------等待唤醒机制；

• wait() 等待，将正在执行的线程释放其执行资格和执行权，并存储到线程池中；
• notify() 唤醒，唤醒线程池中被wait()的线程，一次唤醒一个，而且是任意的；
• notifyAll() 唤醒全部，可以将线程池中的所有wai()线程都唤醒；

其实 所谓唤醒的意思就是让线程池中的线程具备执行资格；

必须注意的是：

• 这些方法都是在同步中才有效，
• 同时这些方法在使用时必须标明所属锁，即锁对象调用；

这样才可以明确出这些方法操作的到底是哪个锁上的线程；这些方法都是定义在Object类中，因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象，能被任意对象调用的方法一定定义在Object类中；

等待唤醒机制的代码实现：

public class Demo {
    public static void main(String[] args) {
        //资源对象
        Resource resource = new Resource();
        //任务对象
        Input input = new Input(resource);
        Output output = new Output(resource);
        //线程对象
        Thread thread1 = new Thread(input);
        Thread thread2 = new Thread(output);
        //开启线程
        thread1.start();
        thread2.start();
    }
}
//输入线程任务类
public class Input implements Runnable{
    private Resource r;
    public Input(Resource r) {
        this.r = r;
    }
    @Override
    public void run() {
        int count = 0;
        while (true) {
            synchronized (r) {
                if (r.isFlag()) {
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if(count % 2 == 0) {
                    r.setName("xiaoming");
                    r.setSex("male");
                } else {
                    r.setName("xiaohua");
                    r.setSex("femal");
                }
                //将对方线程唤醒
                r.setFlag(true);
                r.notify();
            }
        }
    }
}
public class Output implements Runnable {
    private Resource r;
    public Output(Resource r) {
        this.r = r;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (r) {
                if (!r.isFlag()) {
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(r.getName() + ".." + r.getSex());
                //唤醒对方线程
                r.setFlag(false);
                r.notify();
            }
        }
    }
}
//模拟资源类
public class Resource {
    private String name;
    private String sex;
    private boolean flag = false;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

总结

• 同步代码块

  synchronized (锁对象){
      //可能产生线程安全问题的代码
  }
  

  同步代码块的锁对象可以是任意的对象

• 同步方法

  public synchronized void method()
      //可能产生线程安全问题的代码
  }
  

  同步方法中的锁对象是 this

• 静态同步方法

  public synchronized void method()
        //可能产生线程安全问题的代码
  }
  

  静态同步方法中的锁对象是 类名.class

多线程的几种实现方案：

1. 继承Thread类；
2. 实现Runnable接口；
3. 通过线程池，实现Callable接口；

• run()和start()区别：

  1. start()：启动线程，并调用线程中的run方法；
  2. run()：执行该线程对象要执行的任务；

• sleep()和wai()方法的区别：

  1. sleep()：不释放锁对象，释放cpu使用权；在休眠的时间内，不能唤醒；
  2. wait()：释放锁对象，释放cpu使用权；在等待的时间内，能唤醒；