多线程

最新推荐文章于 2021-04-25 09:09:43 发布
最新推荐文章于 2021-04-25 09:09:43 发布
阅读量279 收藏
点赞数
分类专栏： Java 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FST_XUAN/article/details/78156671
版权

线程基础

  1. 线程的五种状态

    1. 创建（New）：使用new创建一个线程时的状态，尚未启动。
    2. 就绪（Runnable）:调用start()启动线程，加入就绪队列，等待被调度进CPU运行
    3. 运行（Run）：处于就绪状态的线程获取了cpu的执行权
    4. 阻塞（Block）：由于某些原因该线程放弃了cpu的使用权。停止执行。除非线程进入可运行的状态，才会有机会获取cpu的使用权。
      • 等待阻塞：运行中的线程执行wait方法，这时候该线程会被放入等待队列。
      • 同步阻塞：运行中的线程获取同步锁，如果该同步锁被别的线程占用，这个线程会成被放入锁池，等待其他线程释放同步锁。
      • 其他阻塞：运行的线程执行sleep或者join方法这个线程会成为阻塞状态。当sleep超时，join等待线程终止，该线程会进入可运行状态。
    5. 死亡（Dead）：线程run mian 执行完毕后，或者因为某些异常产生退出了 run 方法，该线程的生命周期结束。

  2. 线程状态转换图
    状态转换

  3. 线程有关方法

    1. sleep(time)：使线程进入阻塞状态，但不释放锁，睡眠时间发到后自动进入就绪状态。
      作用：给其他线程执行机会。
    2. wait()：使线程进入阻塞状态，释放锁，等到被其他线程notify()时进入就绪状态。
    3. interrupt()：停止线程，调用时抛出中断异常。
    4. setDaemon(true)：后台线程，当所有的前台线程都结束了，后台线程就结束。
      注意：在启动前调用。作用：为前台线程提供服务。
    5. setPriority(Thead.MAX_PRIORITY)：设置线程的优先级（1-10），默认优先级为5。
    6. join()：当A线程执行到B线程的join()时，A就会等待，直到B结束A才会执行。
      作用：临时加入线程，使该线程运行完，其他线程才继续。
    7. yield()：使当前线程放弃分得的CPU时间片，进入就绪状态。
      作用：使同优先级或更高优先级的线程有执行机会。

继承Thread类

  1. 代码演示

    class Test extends Thread 
{
    Test(String name)
    {
        super(name);
    }
    //run()存储线程要运行的代码
    public void run()
    {
        for(int x = 0; x < 60;x++)
        {
            System.out.println(Thread.currentThread().getName()+"   run....."+x);
        }
    }
}

class  ThreadDemo1
{
    public static void main(String[] args) 
    {
        Test t1 = new Test("one");
        Test t2 = new Test("two");
        t1.start();
        t2.start();
    }
}

  2. 存在的不足

    1. 子类无法多继承。
    2. 不适合资源共享。

实现Runnable接口

  1. 代码演示

    class Ticket implements Runnable
{
    private int tick = 100;
    public void run()
    {
        while(true)
        {
            if(tick>0)
            {
                System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
            }
        }
    }
}
class  ThreadDemo3
{
    public static void main(String[] args) 
    {
        Ticket t  = new Ticket();

        //创建线程的同时明确线程要运行的代码
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);

        //启动线程，使线程处于就绪状态，等待被调度
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

  2. 注意：实现Runnable接口的类不是线程类。创建线程对象的是Thread或Thread的子类。

多线程的安全问题

  1. 代码演示安全问题

    class Ticket implements Runnable
{
    //线程的共享数据
    private int tick = 100;
    public void run()
    {
        while(true)
        {
            if(tick>0)
            {
                //为了演示可能出现的问题，让当前线程释放执行权
                try{Thread.sleep(10);} catch(Exception e){}
                System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
            }
        }
    }
}

    当多线程用到共享资源时，由于CPU的时间片特性，不管run()有没有执行完毕，CPU时间片一旦执行完一个线程的时间片，会自动跳转到另一个线程的run()中去执行其时间片，这样就可能导致共享数据的不一致，也即出现了多线程安全问题。

  2. 解决方案

    class Ticket implements Runnable
{
    private int tick = 100;
    public void run()
    {
        while(true)
        {
            //在涉及到共享数据的代码上加互斥锁
            synchronized(this)
            {
                if(tick>0)
                {
                    try{Thread.sleep(10);} catch(Exception e){}
                    System.out.println(Thread.currentThread().getName()+"sale:"+tick--);
                }
            }
        }
    }
}

互斥锁

  1. 互斥锁的理解

    互斥锁相当于公共厕所的一把锁，公共厕所是一个共享资源，为了使当前正在使用资源的人不被其他人打扰，在门上加一把锁，里面的人不开门（释放锁），外面的人就进不去。

  2. 如何判断哪些代码需要加锁

    1. 明确哪些代码是多线程运行代码
    2. 明确共享数据
    3. 明确多线程运行代码中哪些语句是操作共享数据的。

  3. 加锁后同步的前提

    1. 有两个或两个以上的线程
    2. 多个线程使用同一个锁

  4. 加锁的弊端

    多个线程需要判断锁，较为消耗资源。

  5. 锁对象

    1. 同步代码块的锁可以是任意对象。
    2. 同步函数的锁是this。
    3. 静态同步函数的锁是Class对象。

多线程间的通信

  1. 问题描述

    当多个线程在操作同一个资源，但是操作的动作不同（run()不同），就涉及到了线程间的通信问题。

  2. 解决方法：用标记+等待唤醒机制wait()和notify()实现同步

    1. wait()：使正在执行的线程等待，进入阻塞状态。
    2. notify()：唤醒线程池中等待的线程，进入就绪状态。
    3. notifyAll() ：唤醒线程池中所有线程。

    注意：这些方法都在互斥锁中使用，因为它们都被互斥锁对象调用。 以下是代码示例。

    class Res
{
    private String name;
    private String sex;
    private boolean flag = false;   //是否释放锁的标记

    //送入
    public synchronized void  set(String name,String sex)   //加锁
    {
        if(flag)        //有煤了，等，释放锁
            try{this.wait();} catch(Exception e){}  

        this.name = name;
        this.sex = sex;

        flag = true;        //标记有资源了
        this.notify();      //唤醒对方线程，叫对方送走资源
    }

    //送走
    public synchronized void out()
    {
        if(!flag)       //没有资源，等
            try{this.wait();} catch(Exception e){}  

        System.out.println(name+"........"+sex);

        flag = false;   //标记没有资源了
        this.notify();  //唤醒对方线程，叫对方送资源
    }
}

class Input implements Runnable
{
    Res r;
    Input(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        int x = 0;
        while(true)
        {
            if(x == 0)  
                r.set("mike","male");
            else
                r.set("lili","女女女女女女");
            x = (x+1) % 2;
        }
    }
}

class Output implements Runnable
{
    Res r;
    Output(Res r)
    {
        this.r = r;
    }
    public void run()
    {
        while(true)
        {
            r.out();
        }
    }
}

class  ThreadDemo7
{
    public static void main(String[] args) 
    {
        //要操作的共享资源
        Res r = new Res();
        //开启两个线程同时运行
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();
    }
}

  3. 需要同步的几种情况

    1. 两个操作一样的线程：直接加锁（锁对象是本身对象）
    2. 两个操作不一样的线程：加锁+判断标记+等待唤醒机制（notify()）
    3. 两个执行A操作的线程、两个执行B操作的线程：加锁+循环判断标记+等待唤醒机制（notifyAll()）

  4. 生产者消费者问题代码示例

    //共享资源
class Resource
{
    private String name;            //资源名称
    private int count = 1;          //操作资源的次数
    private boolean flag = false;       //是否释放锁的标记

    public synchronized void set(String name)       //隐式的锁机制
    {
        while(flag)                 //有资源
            try{this.wait();} catch(Exception e){}  //等待的同时释放锁

        this.name = name + "--" + count++;
        System.out.println(Thread.currentThread().getName()+"....生产者...."+this.name);

        flag = true;                    //有资源了
        this.notifyAll();               //唤醒所有等待队列中的线程
    }
    public synchronized void out()
    {
        while(!flag)                    //没有资源
            try{this.wait();} catch(Exception e){}

        System.out.println(Thread.currentThread().getName()+"....消费者.........."+this.name);

        flag = false;                   //资源被取走了
        this.notifyAll();               //唤醒所有等待队列中的线程
    }
}

//生产者
class Producer implements Runnable 
{
    private Resource res;
    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            res.set("+商品+");
        }
    }
}

//消费者
class Consumer implements Runnable
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            res.out();
        }
    }
}

class ThreadDemo8
{
    public static void main(String[] args) 
    {
        //共享资源对象
        Resource r = new Resource();

        //生产者、消费者对象操作同一个资源
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        //两个生产者线程、两个消费者线程
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

JDK5.0升级后的同步解决方案

  1. 升级内容

    1. 将同步synchronized替换成Lock接口
    2. 由于wait()、notify()都要标识自己所属的锁，因此将Object中的wait()、notify()、 notifyAll()封装成Condition监视器对象，该对象可以通过Lock锁对象获取，且一个锁可以对应多个监视器对象。

  2. 升级后的好处

    1. 显式的锁机制，使加锁和释放锁操作更透明。
    2. 显式的等待唤醒机制，可以有多个Condition监视器对象，使不会唤醒本方。
    3. 由于一个锁可以对应多个Condition监视器对象，因此不容易发生死锁。

  3. 生产者消费者问题代码示例

    import java.util.concurrent.locks.*;

//要操作的共享资源
class Resource
{
    private String name;                    //资源名称
    private int count = 1;                  //操作资源的次数
    private boolean flag = false;               //是否释放锁的标记
    private Lock lock = new ReentrantLock();        //接口引用指向子类对象
    private Condition condition_pro = lock.newCondition();  //生产者监视器
    private Condition condition_con = lock.newCondition();  //消费者监视器

    //设置资源
    public void set(String name) throws InterruptedException
    {
        lock.lock();        //加锁
        try
        {
            while(flag)
                condition_pro.await();  //生产者等待，没有释放锁

            this.name = name + "--" + count++;
            System.out.println(Thread.currentThread().getName()+"....生产者...."+this.name);

            flag = true;
            condition_con.signal();     //消费者醒来
        }

        finally         //在await()之前必须先释放锁
        {
            lock.unlock();  //释放锁
        }
    }
    //获取资源
    public void out() throws InterruptedException
    {
        lock.lock();        //加锁
        try
        {
            while(!flag)
                condition_con.await();  //消费者等待，没有释放锁

            System.out.println(Thread.currentThread().getName()+"....消费者.........."+this.name);

            flag = false;
            condition_pro.signal();     //生产者醒来
        }
        finally         //在await()之前必须先释放锁
        {
            lock.unlock();
        }
    }
}

//生产者
class Producer implements Runnable 
{
    private Resource res;
    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.set("+商品+");
            }
            catch (InterruptedException e)
            {
            }
        }
    }
}

//消费者
class Consumer implements Runnable
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.out();
            }
            catch (InterruptedException e)
            {
            }
        }
    }
}
class ThreadDemo9
{
    public static void main(String[] args) 
    {
        //创建共享资源对象
        Resource r = new Resource();

        //创建生产者消费者对象，操作同一个资源对象
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);

        //两个生产者线程，两个消费者线程
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(con);

        //开启线程对象
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
FST_XUAN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
kryo、fst实现序列化
点点的博客
09-02 1671
一、fst 介绍：FST fast-serialization 是重新实现的 Java 快速对象序列化的开发包 开源地址：https://gitee.com/mirrors/fst 依赖： <!-- https://mvnrepository.com/artifact/de.ruedigermoeller/fst --> <dependency> <groupId>de.ruedigermoeller</gro
Fst详解（具体计算步骤）
小猪打呼噜
09-26 3万+
Fst，用于衡量种群分化程度，取值从0到1，为0则认为两个种群间是随机交配的，基因型完全相似；为1则表示是完全隔离的，完全不相似。它往往从基因的多样性来估计，比如SNP或者microsatellites(串联重复序列一种，长度小于等于10bp)。是一种以哈温平衡为前提的种群遗传学统计方法。   下面从一个例子来看如何计算Fst：       AA Aa aa 种群1...
Java多线程之synchronized、volatile关键字底层原理
Fstrovsky的博客
05-05 583
文章目录接上一篇用户态与内核态CASUnsafemarkword工具：JOL = Java Object Layoutsynchronized的横切面详解java源码层级字节码层级JVM层级（Hotspot）锁升级过程JDK8 markword实现表：锁重入synchronized最底层实现synchronized vs Lock (CAS)锁消除 lock eliminate锁粗化 lock c...
个性化语言模型的高效动态WFST解码
weixin_43587572的博客
03-21 406
摘要： 我们提出了一种两层缓存机制来加速个性化语言模型下的动态WFST解码。第一层是一个公共缓存，它存储图形的大部分静态部分。这在所有用户中是全局共享的。第二层是私有缓存，用于缓存表示个性化语言模型的图形，该模型仅由特定用户的话语共享。我们还提出了两种简单而有效的预初始化方法，一种是基于广度优先搜索的方法，另一种是基于数据驱动的方法，利用先前的语句来探索解码器的状态。通过一个使用个性化联系人列表的呼叫语音识别任务的实验表明，与不进行预初始化的解码相比，所提出的公共缓存将解码时间缩短了三倍。使用私有缓存可提
线程安全单例设计模式+序列化
sosmmh的博客
02-27 223
懒汉式单例模式会引来线程安全问题，即多线程时可能会创建多个实例，而且在反序列化时也可能会创建新的实例。看了大大们的实现方式，觉得以下一种比较简单方便理解。一、下面是会造成线程安全的饿汉单例模式。用四打印下会发现hashcode不一致public class Singleton { private static Singleton instance = null; ...
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程详解及示例
最新发布
07-20
在多线程环境下，死锁是指两个或多个线程相互等待对方释放资源，导致它们都无法继续执行。活锁则是指线程不断重试获取资源，但由于其他线程持有资源不释放，导致线程陷入无限循环的状态。避免死锁和活锁的关键在于...
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
安卓多线程
04-16
安卓多线程，安卓高级开发中，必备技能，项目开发中都要使用
多线程介绍
10-21
多线程（英语：multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多...
高性能序列化框架FST
z69183787的专栏
11-02 8275
fst是完全兼容JDK序列化协议的系列化框架，序列化速度大概是JDK的4-10倍，大小是JDK大小的1/3左右。 首先引入pom dependency> groupId>de.ruedigermoellergroupId> artifactId>fstartifactId> version>2.04version> dependency> 测试代码 package zookee
多线程基础与基于多线程的简单聊天室
06-24
在IT行业中，多线程是程序设计中的一个重要概念，尤其在Java编程中，它被广泛应用于提高应用程序的并发性能和响应速度。本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的...
多线程示例
03-30
在IT领域，多线程是程序设计中的一个重要概念，尤其在现代计算机系统中，它能够提升应用程序的效率和响应性。MFC（Microsoft Foundation Classes）是微软提供的一个C++类库，用于简化Windows应用程序的开发，包括...
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
Linux多线程编程详解：pthread实践与指南
Linux多线程编程指南是一份由Sun Microsystems提供的文档，专注于在Linux环境下使用POSIX线程库（pthread）进行并发编程。这份文档涵盖了多线程编程的基础概念、设计原则以及在Solaris操作系统中的应用。 1. **概述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值