Java多线程编程详解——快速上手附代码

最新推荐文章于 2024-05-16 10:23:10 发布
最新推荐文章于 2024-05-16 10:23:10 发布
阅读量320 收藏 1
点赞数 1
分类专栏： Java基础 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48610702/article/details/120328415
版权

Java多线程编程详解——快速上手附代码

Java多线程编程方面涉及到的知识，结合B站狂神说视频总结笔记，附代码。

文章目录

一、创建多线程的方法

三种：

  1. 继承Thread类
  2. 实现Runnable接口，将重写run方法，将Runnable实现类作为Thread类的Target创建线程对象，再调用该Thread类的start()方法启动该线程。（这里是用到了静态代理模式，两个类都实现同一个接口，将实际类当作代理类的Target传入构造函数参数中，接着由代理类创建对象代理实际类完成操作）
  3. 实现Callable接口。可以定义返回类型，获取线程执行结果。
    在这里插入图片描述
    多线程创建方法代码示例：
import java.util.concurrent.*;

// 1. 继承Thread类
public class T1 extends Thread{

    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName() + "这是继承Thread类方法");
    }

    public static void main(String[] args) {
        T1 thread1 = new T1();
        // 继承Thread类启动线程
        thread1.run();
        TestRunnable tr = new TestRunnable();
        TestCallable tc = new TestCallable();
        // 启动Runnable线程
        new Thread(tr,"Runnable实现线程").start();
        
//        // Callable启动线程方式一        
//        ExecutorService service = Executors.newFixedThreadPool(3);
//        Future<String> result =  service.submit(tc);
//
//        try {
//            String out = result.get();
//            System.out.println(out);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        } catch (ExecutionException e) {
//            e.printStackTrace();
//        }
//
//        service.shutdown();

        // Callable启动线程方式二
        FutureTask<String> futureTask = new FutureTask<String>(tc);
        new Thread(futureTask).start();
        try {
            String out = futureTask.get();
            System.out.println(out);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

// 2. 实现Runnable接口方式
class TestRunnable implements Runnable{
    
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

// 3. 实现Callable接口方式
class TestCallable implements Callable{

    @Override
    public String call() {
        System.out.println("输出一个人");
        return "小纶纶";
    }
}

二、静态代理

即如上面Runnable实现创建线程即是使用了静态代理模式。
在这里插入图片描述

三、Lambda表达式

作用：简化代码（jdk8新特性）
在这里插入图片描述

注意：函数式接口是Lambda表达式的关键所在。
在这里插入图片描述
在这里插入图片描述

public class LamdaThread {

    //内部静态类实现方式
    static class Like implements ILike{

        @Override
        public void like() {
            System.out.println("I Like You!");
        }
    }

    public static void main(String[] args) {
        Like like1 = new Like();
        like1.like();

        //函数式接口lambda实现方式
        ILike like = () -> {
            System.out.println("This is a lambda!");
        };
        like.like();
    }
}

interface ILike{
    void like();
}

总结：

  • lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就该用代码块包裹；
  • 前提是接口为函数式接口；
  • 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。

四、线程状态

在这里插入图片描述
在这里插入图片描述

五、 常用线程方法

在这里插入图片描述

1. 线程停止

不推荐使用自带的线程内部的停止方法。如：
在这里插入图片描述

在Thread类destroy()方法上面加有@Deprecated注解，左边方法也被划了横线，表示这个方法已经被废弃，使用可能会有bug或弊端。
优质解决方法：可以用一个标志位，在线程体内部加入标志位，更改标志位已终止线程执行。
在这里插入图片描述
在这里插入图片描述

2. 线程休眠——sleep()

在这里插入图片描述

// 模拟演示
	try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

3. 线程礼让——yield()

在这里插入图片描述
方法：Thread.yield()

4. 线程强制执行——join()

在这里插入图片描述

5. 线程状态观测——Thread.State

在这里插入图片描述
在这里插入图片描述
有了线程的状态，我们就能在线程执行的过程中根据线程的状态进行标志，当线程处于某种状态时我们就执行某种操作。比如我们在监测线程状态时发现一个线程在很长一段时间内都是TIME_WAITING状态的话就执行break。线程只能启动一次，一旦进入死亡模式的话就不能再次启动了。

六、线程优先级

在这里插入图片描述

线程优先级默认是5，最高为10，最低为1。使用Thread.getPriority()获取线程的优先级信息，使用Thread.setPriority()设置线程优先级。
注：优先级高并不代表一定是其先执行，只是说在权重分配上其权重更高，实际运行情况还是看CPU执行结果。一般来说权重高的线程优先执行的概率高。

思考：性能倒置问题（指优先级低的线程被执行了，优先级高的反而在等待）
Why？正常来说，无论怎么样，高优先级的任务一来，低优先级任务就会让位，所以似乎必定高优先级任务能拿到CPU，那为啥还会有优先级倒置？
让我们考虑这么个例子，优先级 T1>T2>T3

T3先执行，他执行的时候正好拿到了资源A，意味着别的任务不能访问资源A，而会被阻塞；
这时 T2执行，由于优先级更高，他很轻松的抢占了CPU 然后他成功的访问到了资源B，成为唯一能够访问资源B，拿到锁的幸运儿。有趣的是，资源B也是T3所需要的，但是这不影响，因为按理来说，T2会执行，直到释放B的锁，以及让出CPU，这样T3可以继续执行；
这时出现了T1，他毫不意外的从T2抢占了CPU，但是却没办法执行，因为缺乏资源A！所以理论上他需要T3执行完才能继续执行。。。
你说接下来发生什么？自然是T1被阻塞，然后让出CPU，实际上最先执行的是T2，等T2执行完，T3才能获得CPU（此时因为T1被阻塞了，没办法抢占CPU），继续执行，等到T3执行完，释放T1所需的资源A，最后才轮到T1.

解决方案：
目前据我所知有两种解决方案
1. 优先级继承
我们发现问题出在，一个矛盾，高优先级的任务因为低优先级任务持有的资源（当然不是CPU资源），而阻塞，既然我们没法轻易释放锁，解锁，因为锁需要CPU运行才能释放，那我们干脆直接让，那个获得资源的任务，得到相同的优先级，或者说继承那个高优先级，这样原先的低优先级任务，可以先运行，赶紧用完赶紧走，别打扰我T1干事。

换个角度来看，这就是临时提升CPU的抢占优先级，临时“升官”，为的就是赶紧执行让出资源。

资源让出来以后，再恢复优先级，该干啥干啥：）

这样 一开始你会觉得 这不还是让T3先于T1了嘛？但是你别忘了，我们这层优化可以使得T1不用在T2之后执行

So？不就节省了一个任务嘛？那如果我改变一下条件，假设有100个任务 T1 ~ T100，T100最低，持有T1的资源，你觉得会发生什么事？

很明显T1会被迫等待T2~T99，所有的任务都执行完才能执行！！！！

这就非常显著的性能差异了

2. 优先级天花板
除了优先级继承模式，还有个模式被称为优先级天花板，
这个模式很好玩的在于，他直接避免了阻塞的发生：）优先级继承的机制触发条件是，高优先级任务被手握资源的低优先级任务阻塞，而天花板则是，只要他手握资源，那么在所有可能需要此资源的线程中，他拥有最高优先级，

这意味着，其他资源的占有比CPU的占有更重要，占有其他临界资源，我可以给你配好CPU的使用优先级，但你如果只是占有CPU 实际上你还被阻塞 等同于没有优先。
————————————————
版权声明：本文为CSDN博主「阮菜鸡」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43178828/article/details/113914627

七、守护线程

在这里插入图片描述
Thread.setDaemon(true); 表示将该线程设置为守护线程，默认是false表示是用户线程。
在这里插入图片描述

八、线程同步

在这里插入图片描述

1. synchronized关键字

线程不安全示范：
代码如下：

// 线程不安全示例代码
public class ThreadNotSafe {
   public static void main(String[] args) {
       Ticket t = new Ticket(10);
       Thread thread1 = new Thread(t,"小明");
       Thread thread2 = new Thread(t,"小红");
       Thread thread3 = new Thread(t,"小强");
       
       thread1.start();
       thread2.start();
       thread3.start();
   }
}

class Ticket implements Runnable{
   private int ticket;
   Boolean flag = true;

   public Ticket(int ticket){
       this.ticket = ticket;
   }

   @Override
   public void run() {
       while (flag){
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           buy();
       }
   }

   public void buy(){
       if(ticket <= 0){
           flag = false;
           return;
       }
       System.out.println(Thread.currentThread().getName() +"买到了第" + ticket-- + "张票");
   }
}

上示例模拟火车票购票，三个线程同时执行买票操作，总票数设置为10张，未保证线程安全，运行结果如下：
在这里插入图片描述
可以看到这里有多人买到了同样的票，在这个例子中这样线程是不安全的。

解决方法：
在这里插入图片描述

	// buy方法中加入synchronized关键字进行线程同步控制
    public synchronized void buy(){
        if(ticket <= 0){
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() +"买到了第" + ticket-- + "张票");
    }

Synchronized锁对象内方法时，默认锁的是对象本身 this, 因此对于我们不需要锁本身而是实际操作对象时，可以使用同步块策略。

在这里插入图片描述

2. CopyOnWriteArrayList

测试JUC安全类型的集合，它是线程安全的。java.util.concurrent.CopyOnWriteArrayList

3. 死锁

在这里插入图片描述
在这里插入图片描述
以下为一段死锁代码示例：

public class DeadLock {
    public static void main(String[] args) {
        MakeUp makeUp1 = new MakeUp(0,"灰姑凉");
        MakeUp makeUp2 = new MakeUp(1,"白雪公主");

        new Thread(makeUp1).start();
        new Thread(makeUp2).start();
    }
}

// 口号
class Lipstick{

}

// 镜子
class Mirror{

}

class MakeUp implements Runnable{

    // 需要的资源只有一份，用static来保证
    static Mirror mirror = new Mirror();
    static Lipstick lipstick = new Lipstick();

    int choose;  // 选择
    String girlName;  // 使用化妆品的人

    public MakeUp(int choose, String girlName){
        this.choose = choose;
        this.girlName = girlName;
    }


    @Override
    public void run() {
        // 进行化妆
        if(choose == 0){
            synchronized (mirror){
                System.out.println(girlName + "拿到了镜子");
                synchronized (lipstick){
                    System.out.println(girlName + "拿到了口红");
                }
            }
        }else {
            synchronized (lipstick){
                System.out.println(girlName + "拿到了口红");
                synchronized (mirror){
                    System.out.println(girlName + "拿到了镜子");
                }
            }
        }
    }
}

灰姑凉和白雪公主这两个女孩要化妆，灰姑凉先选择拿口号给自己上个口红先，白雪公主先拿到镜子先照照，但是当前镜子和口红都只有一个，这时候灰姑凉要拿镜子了，但是还拿着口红不放，白雪公主想要画口红了但是同样不放开已经拿到手的镜子，结果两个人进入了僵持，谁也不先让步，结果谁也画不成妆了。
程序死锁，进程永远无法继续运行
在这里插入图片描述

同一资源被两个进程使用，互相持有又不放开，谁都请求不到造成死锁，这里解决的方法就是不要让synchronized代码块持有两个或以上的对象锁，在写代码的时候就要采用合理的策略，避免这种情况的发生，如上例中对一个对象操作完释放掉对象锁。

4. Lock（锁）

在这里插入图片描述

在这里插入图片描述
Lock测试代码：

import java.util.concurrent.locks.ReentrantLock;

public class LockTest {
    public static void main(String[] args) {
        Station s = new Station();
        new Thread(s,"黄牛").start();
        new Thread(s,"小红").start();
        new Thread(s,"小明").start();
    }
}

class Station implements Runnable{
    private int ticket = 1000;
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        buy();
        // 模拟延时
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    private void buy(){
        lock.lock();
        try {
            while (true){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() +"买到了第" + ticket-- + "张票");
                }else {
                    break;
                }
            }
        }finally {
            lock.unlock();
        }
    }
}

九、线程协作

生产者消费者模式

1. 线程通信

在这里插入图片描述

2. 管程法

生产者消费者模型  利用缓冲区解决：管程法。
生产者、消费者、产品、缓冲区
在这里插入图片描述

代码示例：

public class TestGuanCheng {
   public static void main(String[] args) {
       Container maidaolao = new Container();
       Productor productor = new Productor(maidaolao);
       Consumer consumer = new Consumer(maidaolao);

       new Thread(productor).start();
       new Thread(consumer).start();

   }
}

class Chicken{
   int id;
   public Chicken(int id){
       this.id = id;
   }

   public int getId() {
       return id;
   }

   public void setId(int id) {
       this.id = id;
   }
}

class Consumer implements Runnable{
   Container store;
   public Consumer(Container store){
       this.store = store;
   }

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           System.out.println("消费了第" + store.pop().getId() + "只鸡");
       }
   }
}

class Productor implements Runnable{
   Container store;
   public Productor(Container store){
       this.store = store;
   }

   @Override
   public void run() {
       for (int i = 0; i < 100; i++) {
           Chicken c = new Chicken(i);
           store.push(c);
           System.out.println("已经生产了第" + i + "只鸡了");
       }
   }
}


class Container{

   Chicken[] chickens = new Chicken[10];
   int count = 0;

   // 生产
   public synchronized void push(Chicken chicken){
       // 如果容器满了，就需要等待消费者来消费
       if(count == chickens.length){
           // 生产等待
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

       // 如果没满就丢入产品
       chickens[count] = chicken;
       count++;

       // 通知等待中的线程来进行消费
       this.notifyAll();
   }

   // 消费
   public synchronized Chicken pop() {
       // 判断能否消费
       if(count == 0){
           // 消费等待
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

       // 如果可以消费
       count--;
       Chicken chicken = chickens[count];

       // 通知等待中的线程来进行生产
       this.notifyAll();
       return chicken;
   }
}

3. 信号灯法

测试生产者消费者问题2  信号灯法：标志位解决

简单来讲就是利用一个或多个标志位来控制各个线程之间的执行
代码示例：

public class TestXinHaoDeng {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i % 2 == 0){
                this.tv.play("快乐大本营");
            }else {
                this.tv.play("中国好声音");
            }
        }
    }
}

class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.tv.watch();
        }
    }
}

class TV{
    String show;
    // 正在表演，观众等待 T
    // 正在观看，演员等待 F
    Boolean flag = true;

    // 表演
    public synchronized void play(String show){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("表演了" + show);
        // 通知观众观看
        this.notifyAll();
        this.show = show;
        this.flag = !this.flag;
    }

    // 观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("观众观看了" + show);
        // 提醒演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

十、线程池

在这里插入图片描述
在这里插入图片描述
创建一个线程池的方法：
在这里插入图片描述
创建线程池代码示例（newFixedThreadPool（int nThreads）方法）：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
   public static void main(String[] args) {
       // 1. 创建服务，创建线程池
       // newFixedThreadPool 参数为线程池大小，即最大线程数
       ExecutorService se = Executors.newFixedThreadPool(10);

       // 2. 执行
       se.execute(new MyThread());
       se.execute(new MyThread());
       se.execute(new MyThread());
       se.execute(new MyThread());

       // 3. 关闭线程池
       se.shutdown();
   }
}

class MyThread implements Runnable{

   @Override
   public void run() {
       System.out.println(Thread.currentThread().getName());
   }
}

总结

以上能在实际运用多线程有个初步的了解，了解其使用原理的话理解起来也更加轻松了，文章内截图来自B站狂神说多线程详解视频。

事在人为嘛
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程全部源码
10-20
这个资源是学习java多线程的全部代码，之前上传的是部分章节的，看我博客的时候，可以参照着代码看。
java多线程编程技术 +代码实例
kanwoerzi
08-27 233
1. java和他的API都可以使用并发。可以指定程序包含不同的执行线程，每个线程都具有自己的方法调用堆栈和程序计数器，使得线程在与其他线程并发地执行能够共享程序范围内的资源，比如共享内存，这种能力被称为多线程编程（multithreading）,在核心的C和C++语言中并不具备这种能力，尽管他们影响了JAVA的设计。 2. 线程的生命周期 新线程的生命周期从“新生”状态开始。程序启动线程前，...
Java多线程编程
qq_50743381的博客
05-06 724
Java多线程 一、Java多线程编程 1. 进程与线程 在java语言里面最大的特点是支持多线程的开发（也是为数不多支持多线程的编程语言），所以在好着呢哥哥java技术的学习里面，如果不能够对多线程的概念有一个全面并且细致的了解，则在日后进行一些项目的设计的过程之中尤其是并发访问设计的 过程之中就会出现严重的技术缺陷。 如果要理解线程，首先需要了解进程的概念，在传统的DOS系统的时代，其本身有一个特征：如果你电脑上出现了一个病毒，那么所有的程序将无法执行，因为传统的DOS采用的是单进程处理，单进程处理的最
java多线程编程技术详解和实例代码
08-30
主要介绍了 java多线程编程技术详解和实例代码的相关资料,需要的朋友可以参考下
Java多线程编程深入详解.docx
10-24
Java多线程编程深入详解
java多线程编程实战指南 核心篇 代码
02-20
《Java多线程编程实战指南（核心篇）》以基本概念、原理与方法为主线，辅以丰富的实战案例和生活化实例，并从Java虚拟机、操作系统和硬件多个层次与角度出发，循序渐进、系统地介绍Java平台下的多线程编程核心技术及...
JAVA多线程编程实例详解
08-25
主要介绍了JAVA多线程编程,结合实例形式总结分析了多线程、锁、线程池等相关原理及使用技巧,需要的朋友可以参考下
Java编程多线程之共享数据代码详解
08-28
主要介绍了Java编程多线程之共享数据代码详解，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
Java多线程和并发编程
zw21sjrc的专栏
06-03 249
多进程和多线程简介 多线程实现 多线程创建 多线程信息共享 互斥，一次只有一个线程进去 static共享 public class ThreadDemo0 { public static void main(String [] args) { new TestThread0().start(); new TestThread0().start(); new TestThread0().start(); new TestThread0().start(
Java多线程详解及其代码实现
weixin_53331942的博客
05-14 661
多线程01：概述 多线程02：线程，进程，多线程
java多线程编程基础（配合实例）
pingnanlee的专栏
07-03 3048
1、多线程的实现 在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。 1）直接继承Thread的类来说，代码大致框架是： class 类名 extends Thread{ 方法1; 方法2； … public void run(){ // other code… } 属性1； 属性2； … } class hello
Java多线程编程学习chapter1
qq_15914047的博客
09-27 278
java多线程编程技术chapter1 参照代码下载链接：http://download.csdn.net/download/qq_15914047/9996833 Thread类的核心方法较多 1.线程的启动 2.如何线程暂停 3.如何线程停止 4.线程的优先级 5.线程安全相关的问题 进程的概念 进程是操作系统结构的基础，是一次程序的执行，是一个程序及
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 410
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 85
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 333
本文主要提供用java实现的拼图小游戏源代码。
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 501
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
Redis的数据淘汰策略——Java全栈知识（19）
dghehe的博客
05-12 495
数据过期策略是 redis 中设置了 TTL 的数据过期的时候 Redis 的处理策略。数据淘汰策略是 Redis 内存不够的时候，数据的淘汰策略：当 Redis 中的内存不够用时，此时在向 Redis 中添加新的 key, 那么 Redis 就会按照某一种规则将内存中的数据删除掉，这种数据的删除规测被称之为内存的淘汰策略。redis 的内存删除策略有：·noeviction: 不会淘汰任何键值对，而是直接返回错误信息。
java 多线程编程pdf
12-16
该PDF文档可以帮助读者快速了解Java多线程编程的相关知识，并提供实用的编程示例和案例分析，有助于读者掌握Java多线程编程的核心技术和方法。 在Java多线程编程PDF中，读者可以学习到如何创建和启动线程、线程的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值