多线程

第一章 多线程

1.1 并发与并行

• 并发：指两个或多个事件在同一时间段内发生
• 并行：指两个或多个事件在同一时刻发生（同时发生）。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理，线程也是一样的，在宏观角度去理解线程是并发运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个cpu时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

1.2 线程与进程

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前运行程序的执行，进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
  • 简而言之：一个程序运行后至少有一个进程，一个进程可以包含多个线程

线程调度

• 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。

• 抢占式调度：优先让优先级高的进程使用CPU，如果线程的优先级相同，那么会随机选择一个，Java使用的为抢占式调度。

1.3 创建线程类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。java使用线程执行体来代表这段程序流。

Java中通过继承Thread类来创建并启动多线程。

• 1. 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程需要完成的任务，因此把run方法称为程序执行体。
  2. 创建Thread子类的实例，及创建了线程对象
  3. 调用线程对象的start()方法来启用线程

第二章 线程

2.1 多线程原理

2.2 Thread类

构造方法：

• public Thread() :分配一个新的线程对象。

• public Thread(String name) :分配一个指定名字的新的线程对象。

• public Thread(Runnable target) :分配一个带有指定目标新的线程对象。

• public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

• public String getName() :获取当前线程名称。
• public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public void run() :此线程要执行的任务在此处定义代码。
• public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
• public static Thread currentThread() :返回对当前正在执行的线程对象的引用

2.3 创建线程方式二

采用java.lang.Runnable，只需要重写run方法即可。

步骤如下：

1. 定义Runnable接口的实现类，并重写该接口的run方法，该run方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3. 调用线程对象的start方法来启动线程。

2.4 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runnable接口的话，则很容易实现资源共享。

总结：

• 实现Runnable接口比继承Thread类所具有的优势：
  • 适合多个相同的程序代码的线程去共享一个资源
  • 可以避免java中的单继承的局限性
  • 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
  • 线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类

第三章 线程安全

3.1 线程安全

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

通过案例来演示线程的安全问题：

电影院要卖票，我们模拟电影院的卖票过程。

public class Ticket implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        //每个窗口卖票的操作
        // 窗口 永远开启
        while (true) {
            if (ticket > 0) {
                //有票 可以卖
                // 出票操作
                // 使用sleep模拟一下出票时间
                try {Thread.sleep(100);
                } catch (InterruptedException e)
                {
                    // TODO Auto‐generated catch block
                    e.printStackTrace();
                }//获取当前线程对象的名字
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖:" + ticket--);
            }
        }
    }
}

测试类：

public class TicketDemo {
    public static void main(String[] args) {
        //创建线程任务对象
        Ticket ticket = new Ticket();
        //创建三个窗口对象
        Thread t1 = new Thread(ticket, "窗口1");
        Thread t2 = new Thread(ticket, "窗口2");
        Thread t3 = new Thread(ticket, "窗口3");
        //同时卖票
        t1.start();
        t2.start();
        t3.start();
    }
}

运行代码截图如下：

程序中的问题：

1. 相同的票买了两回

2. 不存在的票，比如0和-1

   这种问题，几个线程票数不同步，称为线程不安全

• 线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写

  操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，

  否则的话就可能影响线程安全。

3.2 线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题，Java中提供了同步机制(synchronized)来解决。

有三种方法完成同步操作：、

• 同步代码块
• 同步方法
• 锁机制

3.3 同步代码块

• 同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

格式：

synchronized(同步锁){
    需要同步操作的代码
}

同步锁

对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。

1. 锁对象可以是任意类型
2. 多个线程对象要使用同一把锁

注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着（BLOCKED）

使用同步代码块解决代码：

public class Ticket implements Runnable{
    private int ticket = 100;
    Object lock = new Object();
    @Override
    public void run() {
        //每个窗口卖票的操作
        // 窗口 永远开启
        while (true) {
            synchronized (lock){
                if (ticket > 0) {
                    //有票 可以卖
                    // 出票操作
                    // 使用sleep模拟一下出票时间
                    try {Thread.sleep(100);
                    } catch (InterruptedException e)
                    {
                        // TODO Auto‐generated catch block
                        e.printStackTrace();
                    }//获取当前线程对象的名字
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "正在卖:" + ticket--);
                }
            }

        }
    }
}

3.4 同步方法

• 同步方法：使用synchronized修饰的方法就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。

格式：

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

• 同步锁是谁：
  • 对于非static，同步锁就是this
  • 对于static方法，我们使用当前方法所在类的字节码对象(类名.class)

使用同步方法代码如下：

public class Ticket implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        //每个窗口卖票的操作
        // 窗口 永远开启
        while (true) {
            sellTicket();
            }
    }
    private synchronized void sellTicket() {
        if (ticket > 0) {
            //有票 可以卖
            // 出票操作
            String name = Thread.currentThread().getName();
            System.out.println(name + "正在卖:" + ticket--);
        }
    }
}

3.5 Lock锁

java.util.concuirent.locks.Lock机制提供了比synchronized代码块和synchronized方法更为广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。

Lock锁也称为同步锁，加锁与释放锁方法化了：

• public void lock()：加同步锁
• public void unlocl()：释放同步锁

使用如下：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable{
    private int ticket = 100;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        //每个窗口卖票的操作
        // 窗口 永远开启
        while (true) {
            lock.lock();
            if (ticket > 0) {
                //有票 可以卖
                // 出票操作
                String name = Thread.currentThread().getName();
                System.out.println(name + "正在卖:" + ticket--);
            }
            lock.unlock();
        }
    }
}

第四章 线程状态

4.1 线程状态概述

当线程被创建并启动后，他既不是一启动就进入状态，也不是一直处于执行状态。在线程的生命周期中，API中的java.lang.Thread.State枚举了六种线程状态：

线程状态	导致状态发生的条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己的代码，也可能没有，这取决于操作系统处理器
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态
Waiting(无限等待)	一个线程在等待另一个线程执行一个动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡(run方法执行完毕)

第五章 线程池

5.1 线程池概念

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

合理利用线程池能够带来的三个好处：

1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线程的数目，防止因未消耗过多的内存，而把服务器累趴下。