精华内容
下载资源
问答
  • 多线程的实现和使用场景

    万次阅读 2021-06-09 22:06:20
    多线程的实现和使用场景一、多线程实现方式1.1 Thread实现1.2 Runnable实现二、多线程使用场景1.多线程使用场景1.1 多线程应该最多的场景:1.2多线程的常见应用场景:2.多线程小案列2.1 多线程计算2.2 多线程实现...

    一、多线程实现方式

    1.1 Thread实现

    继承Thread类并重写它的run方法。之后创建这个子类的对象并调用start()方法。下面直接上代码:

    /**
    *描述
    * @author cy
    * @date 2021-06-09
    * @return
    **/
    public class TreadTest  extends  Thread{
        public static void main(String[] args) {
            //创建两个线程
            TreadTest thread1 = new TreadTest();
            TreadTest thread2 = new TreadTest();
            thread1.start();
            thread2.start();
        }
        @Override
        public void run() {
           for (int i = 0;i < 100;i++){
               //分别打印线程名称和i
               System.out.println("threadName:"
               +Thread.currentThread()+";i="+i);
           }
        }
    }
    

    输出结果可以看到两个线程交替打印。线程启动成功。
    在这里插入图片描述

    1.2 Runnable实现

    Runnable的实现方式是实现其接口,下面请看具体的实现代码

    
    /**
     * @author  cy
     * @date  2021-06-09
     *@deprecated  Runnable实现多线程
     */
    public class RunnableDemoTest {
    
        public static void main(String[] args) {
            //新建两个线程
            RunnableDemoTest1 r =  
            new RunnableDemoTest1();
            new Thread(r).start();
            new  Thread(r).start();
        }
    
        /**
         * 通过runnable 方式实现多线程
          */
    static class  RunnableDemoTest1  
                       implements  Runnable{
        @Override
        public void run() {
            for (int i = 0 ;i < 5 ;i++)
                System.out.println("threadName:"
                +Thread.currentThread()+";i="+i);
        }
    }
    }
    
    

    从输出结果中我们可以看到两个线程交替打印。线程启动成功。
    在这里插入图片描述

    二、多线程的使用场景

    1.多线程使用场景

    1.1 多线程应该最多的场景:

    web服务器本身; 各种专用服务器(如游戏服务器);

    1.2多线程的常见应用场景:

    1、后台任务,例如:定时向大量(100w以上)的用户发送邮件; 2、异步处理,例如:发微博、记录日志等; 3、分布式计算

    2.多线程小案列

    2.1 多线程计算

    计算一亿个数字之和,在没有学习多线程之前,也是可以实现的,我们可以通过循环一亿次进行累加,最后得出结果。
    代码如下:

    package trhead;
    
    import java.util.Random;
    
    /**
     * 计算一亿个数之和
     */
    public class SumThreadDemo {
    
        private static double [] nums = new double[1_0000_0000];
        private static Random r  =  new Random();
        private static  double  result = 0.0,result1 = 0.0,result2 = 0.0;
    
        static {
            for (int i =0;i < nums.length ; i++){
                nums[i] = r.nextDouble();
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            SumThreadDemo.m1();
            SumThreadDemo.m2();
        }
    
        /**
         * 使用单线程计算
         */
        private  static  void m1(){
            long startTime = System.currentTimeMillis();
            for (int i = 0;i < nums.length;i++){
                result += nums[i];
            }
            System.out.println(result);
            long endTime = System.currentTimeMillis();
            long countTime = endTime - startTime;
            System.out.println("m1耗时:"+countTime);
        }
    
        /**
         * 使用多线程计算
         */
        private  static  void m2() throws InterruptedException {
    
    
            Thread thread1 =   new Thread(()->{
                for (int i = 0;i < nums.length/2;i++){
                    result1 += nums[i];
                }
            });
    
            Thread thread2 =   new Thread(()->{
                for (int i = nums.length/2;i < nums.length;i++){
                    result2 += nums[i];
                }
            });
            long startTime = System.currentTimeMillis();
            thread1.start();
            thread2.start();
            thread1.join();
            thread2.join();
            System.out.println(result1+ result2);
            long endTime = System.currentTimeMillis();
            long countTime = endTime - startTime;
            System.out.println("m2耗时:"+countTime);
        }
    
    
    
    }
    
    

    从输出结果中可以观察出,两个线程计算结果比单个线程快了将近两倍。如果实际应用中有这种场景,大家可以使用多线程实现。
    在这里插入图片描述

    2.2 多线程实现卖票小程序

    某电影院正在上映某大片,共5张票,而他又有3个售票窗口售票,请设计一个程序模拟该电影院售票。

    多线程实现方式1:

    package trhead;
    
    /**
    *描述
     *  某电影院正在上映某大片,共5张票,
     * 而他又有3个售票窗口售票,请设计一个程序模拟该电影院售票。
    * @author cy
    * @date 2021-06-09
    * @return
    **/
    public class TicketTreadTest extends  Thread{
        //设置票数
        private  int ticket = 5;
        public static void main(String[] args) {
            //创建两个线程
            TicketTreadTest thread1 
                  = new TicketTreadTest();
            TicketTreadTest thread2 
                  = new TicketTreadTest();
            TicketTreadTest thread3 
                  = new TicketTreadTest();
            thread1.start();
            thread2.start();
            thread3.start();
        }
        @Override
        public void run() {
            while(true){
               //分别打印线程名称 和 ticket 数
               System.out.println("threadName:"
               +Thread.currentThread()+";
               ticket="+ticket--);
               if(ticket < 0){
                   break;
                }
           }
        }
    }
    

    结果分析:从下图输出结果中可以分析,使用继承Thread类实现卖票,导致每个窗口都卖了五张票,而这个电影院总共才五张票,多线程出现了超卖现象。原因是继承Thread方式,是多线程多实例,无法实现资源的共享
    在这里插入图片描述

    2.3多线程卖票小程序优化

    在2.2的小程序案列中,我们发现了在多线程的环境下, 由于公共资源可能会被多个线程共享, 也就是多个线程可能会操作同一资源. 当多个线程操作同一块资源时, 很容易导致数据错乱或发生数据安全问题,
    即: 数据有可能丢失, 有可能增加, 有可能错乱.

    我们如何避免这种现象呢?具体看代码:

    package trhead;
    
    /**
     * @author  cy
     * @date  2021-06-09
     *@deprecated  Runnable实现多线程卖票
     */
    public class TicketRunnableDemoTest {
        //设置票数
        private  static int ticket = 5;
    
        public static void main(String[] args) {
            //新建两个线程
            RunnableDemoTest1 r 
                   =  new RunnableDemoTest1();
            new Thread(r).start();
            new  Thread(r).start();
        }
    
        /**
         * 通过runnable 方式实现多线程
          */
    static class  RunnableDemoTest1  
                        implements  Runnable{
        @Override
        public void run() {
            while (ticket > 0){
                saleTicket();
            }
        }
    
            /**
             * 实现卖票方法
             */
        public  void  saleTicket(){
            if(ticket>0){
                System.out.println("threadName:"
                +Thread.currentThread()
                + "正在出票,余票剩余:"+ticket-- +"张");
            }
        }
    }
    }
    
    

    结果分析:从下图输出结果中可以分析,实现Runnable接口进行卖票,电影院总共才五张票,多线程卖票正常。原因是实现Runnable方式,是多线程单实例,可实现资源的共享

    在这里插入图片描述

    2.4多线程卖票小程序优化升级

    细心的小伙伴可能会发现,怎么在2.3输出打印的票数不是从大到小排序的,这跟现实中的卖票场景不一样呐。如果想解决这样的问题,就必须使用同步,所谓的同步就是指多个操作在同一个时间段内只有一个线程进行,其他线程要等待此线程完成之后才可以继续执行
    下面我们通过对2.3代码进行继续优化,实现真实卖票场景。

     /**
    * 通过synchronized实现线程同步
      * 实现卖票方法
      */ public synchronized   void   saleTicket1(){
          if(ticket>0){
              System.out.println("threadName:"
              +Thread.currentThread()
                      + "正在出票,余票剩余:"
                      + +ticket-- +"张");
          }
      }
    

    结果分析:从下图输出结果中可以分析,通过同步代码的方法进行代码的加锁操作,实现了卖票场景。
    在这里插入图片描述


    总结

    这节主要给大家介绍了多线程的实现以及相应的一些使用场景,并且引入了同步的知识点,下一节主要介绍synchronized关键字的使用。
    另外,码字不容易,如果发现小编描述有误,麻烦指摘。

    展开全文
  • 多线程使用场景

    千次阅读 2018-10-25 10:58:32
    1.不阻塞主线程(UI...4.某种任务,虽然耗时,但是不耗CPU的操作时,开启线程,效率会有显著提高。 比如读取文件,然后处理。 磁盘IO是个很耗费时间,但是不耗CPU计算的工作。 所以可以一个线程读取数据,一...

    1.不阻塞主线程(UI线程)

    2.为了更快的速度。主线程专门用来监听请求,子线程专门用来处理请求,可以获得大的吞吐量。web服务

    3.某种虽然优先级很低的服务,但是却要不定时去做。比如Jvm的垃圾回收。

    4.某种任务,虽然耗时,但是不耗CPU的操作时,开启多个线程,效率会有显著提高。

    比如读取文件,然后处理。 磁盘IO是个很耗费时间,但是不耗CPU计算的工作。 所以可以一个线程读取数据,一个线程处理数据。肯定比一个线程读取数据,然后处理效率高。 因为两个线程的时候充分利用了CPU等待磁盘IO的空闲时间。

    5.servlet

    6.FTP下载,多线程操作文件

    7.大量数据插入数据库,采用合适数量的线程

    8.tomcat

    9.后台任务:如定时向大量(100W以上)的用户发送邮件;定期更新配置文件、任务调度(如quartz),一些监控用于定期信息采集
    --------------------- 
    原文:https://blog.csdn.net/qq_36523667/article/details/79328044 
     

    展开全文
  • Java多线程使用场景

    千次阅读 2017-12-08 16:38:16
    使用多线程就一定效率高吗? 有时候使用多线程并不是为了提高效率,而是使得CPU能够同时处理多个事件。 使用场景1 为什么了不阻塞主线程,启动其他线程来做耗时的事情。 比如app开发中耗时的操作都不在UI主线程中...

    使用多线程就一定效率高吗? 有时候使用多线程并不是为了提高效率,而是使得CPU能够同时处理多个事件。

    使用场景1

    为什么了不阻塞主线程,启动其他线程来做耗时的事情。

    比如app开发中耗时的操作都不在UI主线程中做。

    使用场景2

    实现响应更快的应用程序, 即主线程专门监听用户请求,子线程用来处理用户请求。以获得大的吞吐量。
    感觉这种情况下,多线程的效率未必高。 这种情况下的多线程是为了不必等待, 可以并行处理多条数据。

    比如JavaWeb的就是主线程专门监听用户的HTTP请求,然后启动子线程去处理用户的HTTP请求。

    使用场景3

    某种优先级虽然很低的服务,但是却要不定时去做。

    比如Jvm的垃圾回收。

    使用场景4

    某种任务,虽然耗时,但是不耗CPU的操作时,开启多个线程,效率会有显著提高。
    比如读取文件,然后处理。 磁盘IO是个很耗费时间,但是不耗CPU计算的工作。 所以可以一个线程读取数据,一个线程处理数据。肯定比
    一个线程读取数据,然后处理效率高。 因为两个线程的时候充分利用了CPU等待磁盘IO的空闲时间。

    曾几何时想过使用多线程读取磁盘数据, 但是读取磁盘数据的性能瓶颈是IO,而不是CPU。 使用多线程的目的是为了不让CPU闲下来,明显不适合用于读取磁盘数据。

    展开全文
  • 主要给大家介绍了关于JAVA多线程使用场景与注意事项的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者使用java具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 认识多线程多线程使用场景

    千次阅读 2019-08-01 10:13:24
    1 一个对象里面如果有个synchronized方法,某一个时刻内,只要一个线程去调用 其中的一个synchronized方法了,其它的线程都只能等待,换句话说,某一个时刻 内,只能有唯一一个线程去访问这些synchronized方法 2 ...

    1  一个对象里面如果有多个synchronized方法,某一个时刻内,只要一个线程去调用
    其中的一个synchronized方法了,其它的线程都只能等待,换句话说,某一个时刻
    内,只能有唯一一个线程去访问这些synchronized方法
    2  锁的是当前对象this,被锁定后,其它的线程都不能进入到当前对象的其它的
    synchronized方法
    3  加个普通方法后发现和同步锁无关
    4  换成两个对象后,不是同一把锁了,情况立刻变化。
    5  都换成静态同步方法后,情况又变化
    所有的非静态同步方法用的都是同一把锁——实例对象本身,也就是说如果一个实
    例对象的非静态同步方法获取锁后,该实例对象的其他非静态同步方法必须等待获
    取锁的方法释放锁后才能获取锁,可是别的实例对象的非静态同步方法因为跟该实
    例对象的非静态同步方法用的是不同的锁,所以毋须等待该实例对象已获取锁的非
    静态同步方法释放锁就可以获取他们自己的锁。
    所有的静态同步方法用的也是同一把锁——类对象本身,这两把锁是两个不同的对
    象,所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个
    静态同步方法获取锁后,其他的静态同步方法都必须等待该方法释放锁后才能获取
    锁,而不管是同一个实例对象的静态同步方法之间,还是不同的实例对象的静态同
    步方法之间,只要它们同一个类的实例对象!

    展开全文
  • 由于多线程应用程序将程序划分成多个独立的任务,因此可以在以下方面显著提高性能:: (1)多线程技术使程序的响应速度更快,因为用户界面可以在进行其它工作的同时一直处于活动状态。 (2)当前空闲的任务可以将处理器...
  • 多线程使用场景(经典必看)

    千次阅读 2018-10-08 10:44:07
    为什么要使用多线程? 1.防止阻塞主线程,提高吞吐量:  你做WEB,容器帮你做了多线程,但是他只能帮你做请求层面的。简单的说,可能就是一个请求一个线程。或多个请求一个线 程。如果是单线程,那同时只能处理一...
  • 多线程模型主要优势为线程间切换代价较小,因此适用于I/O密集型的工作场景, 因此I/O密集型的工作场景经常会由于I/O阻塞导致频繁的切换线程。同时,多线 程模型也适用于单机多核分布式场景。 多进程模型,适用于CPU...
  • JAVA多线程使用场景和注意事项

    千次阅读 2019-03-15 17:59:58
    我曾经对自己的小弟说,如果你实在搞不清楚什么时候用HashMap,什么时候用...多线程生来就是复杂的,也是容易出错的。一些难以理解的概念,要规避。本文不讲基础知识,因为你手里就有jdk的源码。 线程 Threa...
  • 多线程的应用场景

    万次阅读 多人点赞 2016-03-06 23:55:25
    多线程的应用场景
  • 多线程简单应用场景

    千次阅读 2017-09-07 15:35:06
    多线程简单应用场景注:最近想研究多线程,网上搜索资料,发现多线程的资料很多,但是应用场景却很少,大部分都是指出了怎么开启多线程,却没有一个多线程结合实际场景的举例.比如说最经典的多线程就是多窗口卖票Model,...
  • 如果你取检索网络资料会发现,有人直接不建议把KVO与多线程混合使用,因为KVO的响应和KVO观察的值变化是在一个线程上的,不同的线程可能会导致不可预知的后果。参考资料见这里: (1)http://objccn.io/issue-7-3/ ...
  • 再谈Python多线程--正确的使用场景

    千次阅读 2017-11-16 16:24:52
    多线程是编程过程中经常会使用到的手段,其目的是为了能提高任务执行的效率。在Python中,我们都知道实现多线程主要有2种方式: 使用threading.Thread()方法 继承threading.Thread类 一个简单的多线程的样例如下...
  • C#.NET多线程实例6个(包括多线程基本使用多线程互斥等全部多线程使用实例)
  • 多线程场景 Redis中List队列 LPush 和 remove 是否线程安全? 1.业务场景如下 作者在rabbitmq消息队列场景中,实现了一个监控消息数据全部入库的程序,每个生产者发送消息的同时,插入一个key到 redis 中的 list ...
  • Java多线程 - 为什么要使用多线程

    千次阅读 2018-09-30 04:00:53
    Java多线程一:为什么要使用多线程? 我可以总结成一句话:为了效率或者说性能。 我们可以分析一下下面两个场景 第一个场景——拍卖 假设有诸多用户在手机上进行出价,大屏幕显示当前最高价和出价记录,主持人最后...
  • 多线程 IO多路复用 Python 计算密集型 IO密集型(请求需要长期占有服务) IO密集型 其它语言 - 计算密集型 IO密集型 底层语言(C,C++) 功能独立 关联性强的功能 IO密集型 关于并发编程具体概念及用法请...
  • 多进程适用于CPU密集型,多线程适用于I/O密集型。
  • 多线程的作用和使用场景

    千次阅读 2016-08-11 02:36:09
    为了提高CPU的使用率,采用多线程的方式去同时完 成几件事情而互不干扰, (2)、大多情况下,要用到多线程的主要是需要处理大量的IO操作时或处理的情况需要花大量的时间等等,比如:读写文 件、视频图像的采集、处理、...
  • 万字图解Java多线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,本篇文章将使用实例+图解+源码的方式来解析java...
  • 转载来源: 使用场景:https://my.oschina.net/noahxiao/blog/101558 实例:http://hyxw5890.iteye.com/blog/1578597从使用场景的角度出发来介绍对ReentrantLock的使用,相对来说容易理解一些。可重入概念 若一个...
  • 多线程开发优缺点及应用场景分析

    千次阅读 2019-03-10 11:07:02
    多线程应用场景: 是否需要创建多个线程取决于各种因素。在以下情况下,最适合采用多线程处理: (1)耗时或大量占用处理器的任务阻塞用户界面操作; (2)各个任务必须等待外部资源 (如远程文件或 Internet连接)。 ...
  • 一般而言,多线程的应用,主要解决的是吞吐量(单线程,处理一个请求,多线程,处理多个请求。同一时间,可以处理多个用户的请求)、伸缩性(现在的计算机,估计很少再有那种单核的了吧,然后,如果一直使用单线程...
  • 深入浅出多线程编程实战(五)ThreadLocal详解(介绍、使用、原理、应用场景) 文章目录一、ThreadLocal简介二、ThreadLocal与Synchronized区别三、ThreadLocal简单使用四、ThreadLocal原理五、ThreadLocal 应用场景 ...
  • 1:项目结构 2:代码 package tianyi.demo1; public class demo1 { private int toristDistance;//乌龟跑过的距离 private int rabbitDistance;... * 乌龟线程内部类 */ class Torist extends...
  • 多线程的适用场景是什么?为啥要用多线程 https://zhidao.baidu.com/question/1703254723230484300.html 使用多线程是为了提高程序运行的效率。假如有一个程序,要求用户输入多个算式,计算出结果,并分别打印到...
  • 十一、多线程的应用场景

    千次阅读 2012-01-04 16:28:53
    我们有时貌似熟悉异步、多线程、任务... 一、在什么场景可以使用多线程 想要同时处理多件事:单线程处理不了的,必须使用多线程。(类似于分身术)多个线程分解大任务:用单线程可以做,但是使用多线程可以更快。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 454,360
精华内容 181,744
关键字:

使用多线程场景