文章目录

一、初始多线程

线程和进程

进程是程序向操作系统申请资源的基本单位，线程是进程中可独立执行的最小单位。通常一个进程可以包含多个线程，至少包含一个线程，同一个进程中所有线程共享该进程的资源。

1、根本区别
进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位。
2、资源开销
每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间(在Java中，线程之间是共享堆区和方法区的资源，但是它们拥有着独立的栈区)，每个线程都有自己独立的运行栈和程序计数器，线程之间切换的开销小。
3、包含关系
一个进程里可以包含多个线程。
4、内存分配
同一进程的线程共享本进程的地址空间和资源，而线程之间的地址空间和资源是相互独立的。
5、影响关系
一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。
6、执行过程
每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行。

线程并发、并行、串行

并发
多个任务在同一个CPU核上，按细分的时间片轮流执行，从逻辑上来看任务是同时执行。
并行
单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的“同时进行”。
串行
有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。

二、创建线程

这里讲解创建线程的三种方式。

继承Thread类
实现Runnable接口
实现Callable接口

继承Thread类

使用方法：

创建一个继承Thread类的类。
重写Thread类中的run()方法。
用该类创建线程。
通过start()方法启动线程。

代码如下：

//创建线程的第一种方式：编写继承Thread的线程类。
package thread;
class myThread extends Thread{
    public void run(){
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程->" + i);
        }
    }
}
public class ThreadTest01 {
    public static void main(String[] args) {
        myThread t = new myThread();
        t.start();
    }
}

这种方式现在不是很推荐，好的Java程序应该将并行运行的任务与运行机制解耦合。

实现Runnable接口

使用方法：

创建一个实现(implements)了Runnable接口的类。
实现Runnable接口中的run()方法。
创建Thread类对象，将实现了Runnable接口的类对象通过参数的形式传进去。
通过strat()启动线程。

代码如下：

public class ThreadTest02 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunable());
        t.start();
        }
}
class MyRunable implements Runnable{
    public void run(){
        for(int i = 0; i < 1000; i++){
            System.out.println("分支线程->" + i);
        }
    }
}

该类较常用，因为Java程序要面向接口编程，实现了接口的类还可以继承其他类，而继承了类的类，不能在继承其他类。

实现Callable接口

使用步骤：

创建实现Callable接口的类；
以Callable接口的实现类为参数，创建FutureTask对象；
将FutureTask作为参数创建Thread对象；
调用线程对象的start()方法。
代码如下：

public class ThreadTest09 {
    public static void main(String[] args) {
        FutureTask futureTask = new FutureTask(new myCallable());
        Thread thread = new Thread(futureTask);
        thread.start();
    }
}
class myCallable implements Callable<Integer>{
    public Integer call(){
        System.out.println("Call----->start");
        try {
            Thread.sleep(1000*3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Call----->end");
        return 1000;
    }
}

使用该方法创建线程时，核心方法是call()，与其他方式最大的不同是：该方法有返回值，其返回值类型就是Callable接口中泛型对应的类型。我们通过FutureTask对象调用get()方法，获得该线程的返回值。但是这个方法也有相应的缺点，调用get()方法后，在主线程获得该线程的返回值前，主线程会进入阻塞状态。

注意：调用get()方法会抛出两个异常：InterruptedException、ExecutionException

三、线程的生命周期

线程的6种状态

Java中有如下6种状态

New(新创建)
Runnable(可运行)
Blocked(阻塞)
Waiting(等待)
Timed waiting(计时等待)
Terminated(被终止)

新建状态：
使用new关键字创建一个thread对象，刚刚创建出的这个线程就处于新建状态。在这个状态的线程没有与操作系真正的线程产生关联，仅仅是一个java对象。
可运行：
正在进行运行的线程，只有处于可运行状态的线程才会得到cpu资源。
可运行状态可以分为两类理解：就绪状态和运行状态：
运行状态：拥有抢夺CPU时间片的能力，但还未抢夺成功。
就绪状态：成功抢夺CPU时间片。
阻塞：
在可运行阶段争抢锁失败的线程就会从可运行—>阻塞
等待：
可运行状态争抢锁成功，但是资源不满足，主动放弃锁（调用wait()方法）。条件满足后再恢复可运行状态（调用notiy()方法）。
有时限等待：
类似于等待，不过区别在于有一个等待的时间，到达等待时间后或者调用notiy()，都能恢复为可运行状态。
有两种方式可以进入有时限等待：wait(Long)和sleep(Long)
终结：代码全部执行完毕后，会进入到终结状态，释放所有的资源。

线程状态图

四、中断线程

中断线程作用

Java中可以调用interrupt()向线程发出中断请求，从而使线程中断，中断不会对处于运行状态的线程产生影响，但是可以打断线程的阻塞状态(wait(), sleep())，使其进入就绪状态，并抛出InterruptedException异常。

测试代码如下：

public class ThreadTest06 {
    public static void main(String[] args) {
        Thread t = new Thread(new myRunnable2());
        t.start();
        t.interrupt();
    }
}
class myRunnable2 implements Runnable{
    public void run(){
        System.out.println(Thread.currentThread().getName() + "------>start");
        try {
            Thread.sleep(1000*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "------>end");
    }
}

执行结果如下:

中断线程原理

每一个线程都有一个boolean类型的中断状态，该中断状态初始为false。当一个线程调用interrupted方法时，线程的中断状态被置为true。对于一个运行状态的线程来说，没有什么影响，但是对于阻塞状态的线程来说，遇到中断状态时(true)，会抛出一个InterruptedException，同时将中断状态重新置为false。

测试代码如下：

public class ThreadTest06 {
    public static void main(String[] args) {
        Thread t = new Thread(new myRunnable2());
        t.start();
    }
}
class myRunnable2 implements Runnable{
    public void run(){
        System.out.println(Thread.currentThread().getName() + "------>start");
        System.out.println("中断前：" + Thread.currentThread().isInterrupted());
        Thread.currentThread().interrupt();
        System.out.println("中断后(遇到堵塞之前)：" + Thread.currentThread().isInterrupted());
        System.out.println();
        try {
            Thread.sleep(1000*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("中断后(遇到堵塞之后)：" + Thread.currentThread().isInterrupted());
        System.out.println(Thread.currentThread().getName() + "------>end");
    }
}

运行结果如下：

关于中断的相关方法

public void interrupt()
向线程发出中断请求，线程的中断状态被置为true。
public static boolean interrupted()
测试当前线程(正在执行的线程)是否被中断，并将中断状态重置为false。
public boolean isInterrupted()
测试线程的中断状态，但是并不会重置中断状态。

五、线程的属性

这里会对线程优先级和守护线程进行说明。

线程优先级

Java线程的优先级属性本质上只是一个给线程调度器的提示信息，以便于线程调度器决定优先调度哪些线程运行，也可以理解为，优先级高的线程更容易抢夺到CPU时间片。每个线程的优先级都在1到10之间，1的优先级为最低，10的优先级为最高，在默认情况下优先级都是Thread.NORM_PRIORITY（常数 5）。

虽然开发者可以定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。

常用方法和属性

static int MIN_PRIORITY
线程的最小优先级，最小优先级为1。
static int MAX_PRIORITY
线程的最大优先级，最大优先级为10。
static int NORM_PRIORITY
线程的默认优先级，默认优先级为5。
public final int getPriority()
获得线程的优先级。
public static void yield()
让当前线程处于让步状态，放弃CPU时间片，回到就绪状态，重新抢夺CPU时间片。
public final void setPriority(int newPriority)
设置线程的优先级，但是必须在允许的范围内。

守护线程

Java 中的线程分为两种：守护线程和用户线程。任何线程都可以设置为守护线程和用户线程，通过方法setDaemon(true)可以把该线程设置为守护线程，反之则为用户线程。

用户线程：运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程。

守护线程：运行在后台，为其他前台线程服务，比如垃圾回收线程，JIT（编译器）线程就可以理解为守护线程。一旦所有用户线程都结束运行，守护线程会随 JVM 一起结束工作。

守护线程应该永远不去访问固有资源，如文件、数据库，因为它会在任何时候甚至在一个操作的中间发生中断。

注意事项：

setDaemon(true)必须在start()方法前执行，否则会抛出IllegalThreadStateException。
在守护线程中产生的新线程也是守护线程。
不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑。
守护线程中不能依靠finally块的内容来确保执行关闭或清理资源的逻辑。因为我们上面也说过了一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作，所以守护线程中的finally语句块可能无法被执行。

相关方法

public final void setDaemon(boolean on)

将线程设置为守护线程。

六、线程同步

同步
多个线程访问共享资源时，只有当一个线程访问结束后其它线程才能继续方法。
异步
多个线程即使在访问共同资源时也互不影响，各自完成各自的任务。

线程竞争产生的风险

当两个线程存取相同对象，并且每一个线程都调用了修改线程状态的方法，将会发生什么呢？

下面用代码演示：

首先创建一个银行账户类，如下：

public class Account {
    //账号
    private String actno;
    //余额
    private int banlance;
    //构造器
    public Account() {
    }
    public Account(String actno, int banlance) {
        this.actno = actno;
        this.banlance = banlance;
    }
    //setter and getter
    public void setBanlance(int banlance) {
        this.banlance = banlance;
    }
    public int getBanlance() {
        return banlance;
    }
    //取钱操作
    public void takeOut(Account act, int takeOut){
        int newBanlance = act.getBanlance() - takeOut;
        //这里sleep()只是为了让效果更加明显
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        act.setBanlance(newBanlance);
        System.out.println( Thread.currentThread().getName() + "取出：" + takeOut + "   剩余：" + newBanlance);
    }
}

然后我们实现一个Runnable类，如下：

class myRunnable implements Runnable{
  //银行账户对象
    Account act;
    //要取出的金额
    int takeOut;
    //构造器
    public myRunnable(){
    }
    public myRunnable(Account act, int takeOut){
        this.act = act;
        this.takeOut = takeOut;
    }
    public void run(){
        act.takeOut(act,takeOut);
    }
}

然后我们用两个线程同时对一个账户进行取钱操作，如下：

class Test{
    public static void main(String[] args) {
        Account act = new Account("Joken",10000);
        //去五次钱，每次取五千
        Thread t1 = new Thread(new myRunnable(act,5000));
        Thread t2 = new Thread(new myRunnable(act,5000));
        t1.start();
        t2.start();
    }
}

程序运行结果如下：

取了两次钱，但是余额仍然还有5000。

对产生风险的解释

产生以上问题的原因在于：act.takeOut(act,takeOut)并不是一个原子操作

这条指令会被分解为：

int newBanlance = act.getBanlance() - takeOut;
计算出处取钱后剩余的余额。
act.setBanlance(newBanlance);
更新余额到对象账户种。
打印账户余额信息。

注意: 在这里我并未将每一个操作都分解为原子操作，因为这里的样例线程较少，操作也很少，为了方便讲解所以将风险忽略，但是在实际开发中并不能忽略。

现在，线程一执行完了第一步，然后他被剥夺了CPU执行权，线程二又开始执行第一步，虽然线程一取了5000元，但是还没来得及更新，所以线程二在执行时，账户对象的余额仍然是10000元，这样就产生了错误。

synchronized关键字实现线程同步

synchronized关键字是用来控制线程同步的。在多线程的环境下，synchronized控制的代码段不被多个线程同时执行，以达到保证并发安全的效果。
synchronized关键字实现的锁称为内部锁，内部锁是一种排他锁，能够保证原子性、可见性和有序性。之所以被称为内部锁，是因为线程对内部锁的申请与释放的动作都是由Java虚拟机负责实现的，开发者看不到这个锁的获取和释放过程。

将上部分代码通过synchronized改进，如下：

public void takeOut(Account act, int takeOut){
         synchronized (this){ 
            int newBanlance = act.getBanlance() - takeOut;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            act.setBanlance(newBanlance);
            System.out.println( Thread.currentThread().getName() + "取出：" + takeOut + "   剩余：" + newBanlance);
        }
 }

对以上代码的解释：

synchronized (this){ … }，意味着想要执行花括号中的代码，首先要在锁池中找到this的对象锁，找到锁后该线程才会进入可运行状态，没找到锁他就会进入阻塞状态，直到它在锁池中找到这个对象锁。(其它线程将这个锁释放)。
两个线程同时对一个账户对象进行取钱操作，其中一个线程会先到账户对象锁，另一个线程找不到锁就会进入阻塞状态，当获得对象锁的线程将所有指令完成之后就会归还账户对象锁，处于阻塞状态的线程就会进入可运行状态。

**synchronized的三种用法 **

用法一：

synchronized(共享对象){
    //同步代码
}

用法二：

synchronized 加在实例方法上，锁的是this，同步整个方法体。

public synchronized void test(){......}

synchronized 加在静态方法上，找的是类锁，一个类无论new几个对象都只有一个类锁。

用法三：

public static synchronized void test(){......}

七、死锁

死锁是指两个或两个以上的进程（线程）在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

死锁样例：

首先创建两个线程类，如下：

class myThread extends Thread{
    Object o1;
    Object o2;
    public myThread(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o1){
            System.out.println(Thread.currentThread().getName() + "拿到o1的锁，准备拿o2的锁");
            synchronized (o2){
                System.out.println(Thread.currentThread().getName() + "拿到o2的锁");
            }
        }
    }
}
class myThread2 extends Thread{
    Object o1;
    Object o2;
    public myThread2(Object o1, Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        synchronized (o2){
            System.out.println(Thread.currentThread().getName() + "拿到o2的锁，准备拿o1的锁");
            synchronized (o1){
                System.out.println(Thread.currentThread().getName() + "拿到o1的锁");
            }
        }
    }

创建这两个线程类对象，并传入相同对象，如下：

public class deadLock {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        myThread t1 = new myThread(o1,o2);
        myThread2 t2 = new myThread2(o1,o2);
        t1.start();
        t2.start();
    }
}

运行结果如下：

八、简单实现生产消费者问题

生产消费者问题是多线程经典问题，其中生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据

代码实现

public class ThreadApplication {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        ConsumerThread consumer = new ConsumerThread(list);
        ProcuderThread procuder = new ProcuderThread(list);
        consumer.setName("消费者");
        procuder.setName("生产者");
        consumer.start();
        procuder.start();
    }
}
//消费者线程
class ConsumerThread extends Thread{
    List<String> list = new ArrayList<>();
    public ConsumerThread(List<String> list){
        this.list = list;
    }
    public void run(){
        while(true){
            synchronized (list){
                if(list.isEmpty()){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "消费了" + list.remove(0));
                list.notify();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//生产者线程
class ProcuderThread extends Thread{
    int i = 1;
    List<String> list = new ArrayList<>();
    public ProcuderThread(List<String> list){
        this.list = list;
    }
    public void run(){
        while(true){
            synchronized (list){
                if(list.size() == 10){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                list.add("产品" + i);
                System.out.println(Thread.currentThread().getName() + "生产了" + list.get(list.size() - 1));
                i++;
                list.notify();
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

编译结果如下：

Java多线程

文章目录

一、初始多线程

线程和进程

线程并发、并行、串行

二、创建线程

继承Thread类

实现Runnable接口

实现Callable接口

三、线程的生命周期

线程的6种状态

线程状态图

四、中断线程

中断线程作用

中断线程原理

关于中断的相关方法

五、线程的属性

线程优先级

守护线程

六、线程同步

线程竞争产生的风险

对产生风险的解释

synchronized关键字实现线程同步

七、死锁

八、简单实现生产消费者问题

相关方法

代码实现

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java多线程

文章目录

一、初始多线程

线程和进程

线程并发、并行、串行

二、创建线程

继承Thread类

实现Runnable接口

实现Callable接口

三、线程的生命周期

线程的6种状态

线程状态图

四、中断线程

中断线程作用

中断线程原理

关于中断的相关方法

五、线程的属性

线程优先级

守护线程

六、线程同步

线程竞争产生的风险

对产生风险的解释

synchronized关键字实现线程同步

七、死锁

八、简单实现生产消费者问题

相关方法

代码实现

热门文章

最新文章

相关课程

相关电子书

相关实验场景