核心类库——多线程

最新推荐文章于 2024-06-10 21:57:08 发布

芒果不是芒

最新推荐文章于 2024-06-10 21:57:08 发布

阅读量105

点赞数

分类专栏： java学习路线 # 核心类库文章标签： java 后端

本文链接：https://blog.csdn.net/YuanLuo0911/article/details/121010958

版权

java学习路线同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

核心类库

5 篇文章 0 订阅

订阅专栏

一、多线程

1 线程与进程

进程:是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程 :

是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程
线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程
所有的线程都拥有自己的栈空间，共用一份堆内存

2 线程调度

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

2. 抢占式调度：

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

3 同步与异步

同步：排队执行 , 效率低但是安全.

异步：同时执行 , 效率高但是数据不安全

4 并发与并行

并发：指两个或多个事件在同一个时间段内发生。

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

5 启动线程

5.1 继承Thread类

通过继承Thread类来创建并启动多线程步骤如下：

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

示例代码：


public class MyThread extends Thread{
    /**
     * run方法就是线程执行的任务方法
     */
    @Override
    public void run(){
        //调用thread对象的start()可以启动任务，并触发以下的执行路径
        for (int i = 0;i < 10;i++){
            System.out.println("MyThread" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();//启动线程
        for (int i = 0;i < 10;i++){
            System.out.println("主线程"+i);
        }
    }
}

运行结果：
主方法0
MyThread0
主方法1
MyThread1
MyThread2
MyThread3
MyThread4
MyThread5
MyThread6
MyThread7
MyThread8
MyThread9
主方法2
主方法3
主方法4
主方法5
主方法6
主方法7
主方法8
主方法9

因java使用的是抢占式调度，所以上述代码每次运行的结果可能不一致。

执行流程图如下：
在这里插入图片描述

5.2 实现Runnable接口

实现Runnable接口创建并启动多线程的步骤如下：

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

示例代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0;i < 5;i++){
            System.out.println("MyThread" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
        for (int i = 0;i < 5;i++){
            System.out.println("主方法"+i);
        }
    }
}

实现Runnable与Thread相比有如下优势：

通过创建任务，然后给线程分配的方式来实现的多线程，适合多个相同的程序代码的线程去处理统一资源的情况
可以避免单继承所带来的局限性
任务与线程本身是分离的，提高了程序的健壮性，代码可以多个线程共享

5.3 匿名内部类

匿名内部类本质上也是一个类实现了Thread或者Runnable接口，重写了run方法，只不过这个类没有名字，直接作为参数传入Thread类，示例代码：

public class Demo {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run(){
                for (int i = 0;i < 10;i++){
                    System.out.println("MyThread" + i);
                }
            }
        }.start();
        for (int i = 0;i < 10;i++){
            System.out.println("主方法"+i);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
       new Thread(new Runnable() {
			public void run() {
				 for (int i = 0;i < 10;i++){
                    System.out.println("MyThread" + i);
                }
			}
		}).start();
        for (int i = 0;i < 10;i++){
            System.out.println("主方法"+i);
        }
    }
}

6 常用方法

获取线程名称：Thread.currentThread().getName()

设置线程名称：Thread.setName(“新名称”)

线程休眠：Thread.sleep()

线程阻塞：Thread.interrupt()

守护线程：Thread.setDaemon(true) ------一定要在线程启动前设置

线程分为守护线程与用户i西安城
用户线程：当一个进程不包含任何的存活用户线程时，进行结束
守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程自动死亡

7 线程安全与线程不安全

7.1 线程安全

线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。

7.2 线程不安全

线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。

线程不安全例子：

  public class Demo2 {
    public static void main(String[] args) {
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }

    static class Ticket implements Runnable{
        //票数
        private int count = 5;
        @Override
        public void run() {
            while(true){
                if(count>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //卖票
                    System.out.println("正在出票...");
                    count--;
                    System.out.println(Thread.currentThread().getName() +"出票成功，余票为：" + count);
                }
            }
        }
    }
}
运行结果：
    正在出票...
    正在出票...
    Thread-1出票成功，余票为：3
    正在出票...
    Thread-1出票成功，余票为：2
    正在出票...
    Thread-1出票成功，余票为：1
    正在出票...
    正在出票...
    Thread-2出票成功，余票为：-1
    Thread-1出票成功，余票为：0
    Thread-0出票成功，余票为：4

运行结果明显不符合正常逻辑

7.3 如何保证线程安全

同步代码块

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

格式:

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

static class Ticket implements Runnable{
    //票数
    private int count = 5;
    Object lock = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (lock){
                if(count>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //卖票
                    System.out.println("正在出票...");
                    count--;
                    System.out.println(Thread.currentThread().getName() +"出票成功，余票为：" + count);
                }
            }

        }
    }

运行结果：

正在出票...
Thread-2出票成功，余票为：4
正在出票...
Thread-2出票成功，余票为：3
正在出票...
Thread-2出票成功，余票为：2
正在出票...
Thread-2出票成功，余票为：1
正在出票...
Thread-2出票成功，余票为：0

同步方法

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

格式：

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


static class Ticket implements Runnable{
    //票数
    private int count = 5;
    Object lock = new Object();
    @Override
    public void run() {
        while(true){
            boolean flag = sale();
            if (!flag){
                break;
            }
        }
    }

    public synchronized boolean sale(){
        if(count>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卖票
            System.out.println("正在出票...");
            count--;
            System.out.println(Thread.currentThread().getName() +"出票成功，余票为：" + count);
            return true;
        }else{
            return false;
        }
    }
}

运行结果:

正在出票...
Thread-2出票成功，余票为：4
正在出票...
Thread-2出票成功，余票为：3
正在出票...
Thread-2出票成功，余票为：2
正在出票...
Thread-2出票成功，余票为：1
正在出票...
Thread-2出票成功，余票为：0

Lock锁

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

Lock锁也称同步锁，加锁与释放锁方法如下：

public void lock() :加同步锁。

public void unlock() :释放同步锁。

static class Ticket implements Runnable{
    //票数
    private int count = 5;
    //显示锁
    private Lock l = new ReentrantLock();
    @Override
    public void run() {
        while(true){
            l.lock();
            if(count>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //卖票
                System.out.println("正在出票...");
                count--;
                System.out.println(Thread.currentThread().getName() +"出票成功，余票为：" + count);

            }else{
                break;
            }
            l.unlock();
        }
    }
}

8 线程死锁（DeadLock）

8.1 死锁概述

线程死锁是指两个或两个以上的线程互相持有对方所需要的资源，由于synchronized的特性，一个线程持有一个资源，或者说获得一个锁，在该线程释放这个锁之前，其它线程是获取不到这个锁的，而且会一直死等下去，因此这便造成了死锁。

8.2 死锁产生的条件

互斥条件：一个资源，或者说一个锁只能被一个线程所占用，当一个线程首先获取到这个锁之后，在该线程释放这个锁之前，其它线程均是无法获取到这个锁的。
占有且等待：一个线程已经获取到一个锁，再获取另一个锁的过程中，即使获取不到也不会释放已经获得的锁。
不可剥夺条件：任何一个线程都无法强制获取别的线程已经占有的锁。
循环等待条件：线程A拿着线程B的锁，线程B拿着线程A的锁。

死锁演示：

public class Demo04 {
    public static void main(String[] args) {
        //线程死锁
        Culprit c = new Culprit();
        Police p = new Police();
        new MyThread(c,p).start();
        c.say(p);
    }
    static class MyThread extends Thread{
        private Culprit c;
        private Police p;
        public MyThread(Culprit c,Police p){
            this.c = c;
            this.p = p;
        }
        @Override
        public void run() {
            p.say(c);
        }
    }
    //罪犯
    static class Culprit{
        public synchronized void say(Police p){
            System.out.println("罪犯：你放了我，我放了人质");
        }
        public synchronized void fun(){
            System.out.println("罪犯被放走了，罪犯也放了人质");
        }
    }
    //罪犯
    static class Police {
        public synchronized void say(Culprit c) {
            System.out.println("警察：你放了人质，我放了你");
        }

        public synchronized void fun() {
            System.out.println("警察救了人质，但罪犯逃了");
        }
    }
}

运行结果

罪犯：你放了我，我放了人质
警察：你放了人质，我放了你

这样便造成了死锁，p.say()与c.say()都想拿着对方

8.3 如何避免死锁

加锁顺序：线程按照相同的顺序加锁。
加锁时限，线程获取锁的过程中限制一定的时间，如果给定时间内获取不到，就算了，别勉强自己。这需要用到Lock的一些API。

8.4 死锁检测

在发生死锁之后，程序就卡住了没有任何反应，但程序仍在运行，因此需要借助一些

首先使用 jps -l 显示正在运行的虚拟机进程，并显示虚拟机执行主类(main函数所在的类)名称以及这些进程的本地虚拟机唯一ID
使用 jstack + id 进行跟踪排查

9 线程的状态

Java中线程的状态分为6种。

初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
阻塞(BLOCKED)：表示线程阻塞于锁。
等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
终止(TERMINATED)：表示该线程已经执行完毕。

在这里插入图片描述

二、Callable

面试有人会问：线程的实现方式有几种？

很多人可能回答：2种，继承Thread类，实现Runnable接口。

很多忽略了callable这种方式。

也许有人知道callable，也知道callable和Runnable的区别是callable可以有返回值，也可以抛出异常的特性，而Runnable没有。

注意callable可以有返回值，也可以抛出异常这点很关键。

Callable使用步骤

编写类实现Callable接口 , 实现call方法

class XXX implements Callable<T> { 
    @Override 
    public <T> call() throws Exception { 
        return T; 
    } 
}

创建FutureTask对象 , 并传入第一步编写的Callable类对象
```
FutureTask<Integer> future = new FutureTask<>(callable); 
```
通过Thread,启动线程
```
new Thread(future).start();
```

Runnable 与 Callable 接口定义

//接口定义 
//Callable接口 
public interface Callable<V> { 
    V call() throws Exception;
}
//Runnable接口 
public interface Runnable { 
    public abstract void run(); 
}

Runnable 与Callable的相同点

都是接口
都可以编写多线程程序
都采用Thread.start()启动线程

Runnable 与 Callable的不同点

Runnable没有返回值；Callable可以返回执行结果
Callable接口的call()允许抛出异常；Runnable的run()不能抛出

Callable获取返回值

Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执

行，如果不调用不会阻塞。

三、线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。线程池就是一个容纳多个线程的容器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

线程池的好处

降低资源消耗。
提高响应速度。
提高线程的可管理性。

1 线程池类型 ExecutorService

1.1 缓存线程池

/**
* 缓存线程池. 
* (长度无限制) 
* 执行流程: 
* 	1. 判断线程池是否存在空闲线程 
* 	2. 存在则使用 
* 	3. 不存在,则创建线程 并放入线程池, 然后使用 
*/ 
ExecutorService service = Executors.newCachedThreadPool(); 
//向线程池中 加入 新的任务 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
}); 
service.execute(new Runnable() { 
    @Override
    public void run() {
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
}); 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
});

1.2 定长线程池

/**
* 定长线程池. 
* (长度是指定的数值) 
* 执行流程:
*	 1. 判断线程池是否存在空闲线程 
*	 2. 存在则使用 
*	 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
* 	4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 */ 
ExecutorService service = Executors.newFixedThreadPool(2); 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
}); 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
});

1.3 单线程线程池

效果与定长线程池创建时传入数值1 效果一致.

/**
* 单线程线程池. 
* 执行流程: 
* 1. 判断线程池的那个线程是否空闲 
* 2. 空闲则使用 
* 3. 不空闲,则等待 池中的单个线程空闲后 使用
*/ 
ExecutorService service = Executors.newSingleThreadExecutor(); 
service.execute(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName()); 
    } 
});
service.execute(new Runnable() { 
    @Override
    public void run() { 
        System.out.println("线程的名称:"+Thread.currentThread().getName());
    } 
});

1.4 周期性任务定长线程池

public static void main(String[] args) { 
    /**
    * 周期任务 定长线程池. 
    * 执行流程: 
    * 1. 判断线程池是否存在空闲线程 
    * 2. 存在则使用 
    * 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用 
    * 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 
    *
    * 周期性任务执行时: 
    * 定时执行, 当某个时机触发时, 自动执行某任务 .
    */
    ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
    /**
    * 定时执行 
    * 参数1. runnable类型的任务 
    * 参数2. 时长数字 
    * 参数3. 时长数字的单位 
    */ 
    /*service.schedule(new Runnable() { 
    	@Override 
    	public void run() { 
    		System.out.println("俩人相视一笑~ 嘿嘿嘿"); 
   		} 
   	},5,TimeUnit.SECONDS); 
   	*/
    /**
    * 周期执行 
    * 参数1. runnable类型的任务 
    * 参数2. 时长数字(延迟执行的时长) 
    * 参数3. 周期时长(每次执行的间隔时间) 
    * 参数4. 时长数字的单位 
    */ 
    service.scheduleAtFixedRate(new Runnable() { 
        @Override 
        public void run() { 
            System.out.println("俩人相视一笑~ 嘿嘿嘿"); 
        } 
    },5,2,TimeUnit.SECONDS); 
}

芒果不是芒

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
核心类库——多线程

一、多线程1 线程与进程**进程 ????*是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间线程 :是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行. 一个进程最少有一个线程线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程所有的线程都拥有自己的栈空间，共用一份堆内存2 线程调度**1. 分时调度：**所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。2. 抢占式调
复制链接

扫一扫