精华内容
下载资源
问答
  • 多场景使用
    万次阅读
    2022-03-27 10:41:41


    一、微服务场景下Nginx的使用

    Nginx默认使用轮询算法

    1.最小活跃数算法

    问题:当客户端给Nginx发送查询商品的请求时,Nginx把请求转发给5001 和 5002 ,如果5002处理请求比较慢,会导致请求堆积在5002。如何解决请求堆积问题?

    解决方案:最小活跃数算法

    #user  nobody;
    worker_processes  1;
    
    #error_log  logs/error.log;
    #error_log  logs/error
    更多相关内容
  • 文章目录一、RabbitMQ多场景使用情况分析1.一个生产者/个消费者(全部消费)1.1 生产者1.2 消费者1.3 原理分析2.一个生产者/个消费者(选择消费)2.1 生产者2.2 消费者2.3 原理分析3.个生产者/一个消费者...
    展开全文
  • 文章目录一、创建主题和分区二、Kafka多场景使用情况分析1. 一、创建主题和分区 /// <summary> /// 创建分区(更新分区) /// </summary> /// <param name="topic"></param> /// <param ...


    一、创建主题和分区

    /// <summary>
    /// 创建分区(更新分区)
    /// </summary>
    /// <param name="topic"></param>
    /// <param name="Partitions"></param>
    /// <returns></returns>
    [HttpGet(
    展开全文
  • 线程的实现和使用场景

    万次阅读 多人点赞 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关键字的使用。
    另外,码字不容易,如果发现小编描述有误,麻烦指摘。

    展开全文
  • 文章目录一、微服务场景下的RabbitMQ二、微服务场景下RabbitMQ的使用1.RabbitMQ的安装2.RabbitMQ的使用2.1 基本使用2.1.1 消费端挂了(自动确认)2.1.2 消费端挂了(手动确认)2.1.3 队列消息堆积(个消费端)...
  • 文章目录一、微服务场景下Kafka的使用1.Kafka的安装2.Kafka的使用2.1 基本使用2.1.1 消费端挂了(自动确认)2.1.2 消费端挂了(手动确认)2.1.3 Kafka挂了 一、微服务场景下Kafka的使用 1.Kafka的安装 Kafka下载...
  • 文章目录一、限流二、Nginx多场景使用问题分析之限流1.Nginx限流2.Nginx客户端限流3.客户端IP平滑限流4.客户端IP平滑限流-突发5.客户端IP平滑限流-立即突发 一、限流 限流可以认为服务降级的一种,限流就是限制系统...
  • 文章目录一、Nginx多场景使用问题1.代理缓存2.参数详解 一、Nginx多场景使用问题 1.代理缓存 情况:当客户端给Nginx发送查询商品的请求时,Nginx把请求转发给5001 和 5002 ,如果转发到5001和5002,两个实例处理能力...
  • 文章目录前言1.HTTPS介绍2.HTTPS设计目标一、Https应用场景1.证书生成1.1 使用openSSL工具生成2.Nginx配置HTTPS3.Nginx配置HTTP转发HTTPS总结 前言 1.HTTPS介绍 HTTPS (全称:Hyper Text Transfer Protocol over ...
  • 文章目录前言一、Nginx多场景使用问题分析之动静分离1.同一虚拟主机使用2.不同虚拟主机使用3.动静分离共享资源 前言 在Web开发中,通常来说,动态资源其实就是指那些后台资源,而静态资源就是指HTML,JavaScript,...
  • ThreadLocal使用场景

    千次阅读 2021-08-23 16:36:57
    JDK1.2的版本中就提供java.lang.ThreadLocal类,每一个ThreadLocal能够放一个线程级别的变量, 它本身能够被个线程共享使用,并且又能够达到线程安全的目的,且绝对线程安全。 ThreadLocal包含了四个方法: void ...
  • Java 线程的应用场景

    千次阅读 多人点赞 2022-05-01 09:49:54
    实现线程安全的方式有很,这里使用Java Lock 接口中的方法实现。 代码示例 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 测试类 */ public class DemoTest {...
  • mongodb 使用场景

    千次阅读 2021-09-06 23:54:53
    使用C++编写。MongoDB特点: a.面向集合的存储:适合存储对象及JSON形式的数据。 b.动态查询:mongo支持丰富的查询表达方式,查询指令使用JSON形式的标记,可轻易查询文档中的内嵌的对象及数组。 c.完整的...
  • 线程池的使用场景

    千次阅读 2022-04-20 12:09:22
    1、提高效率 创建好一定数量的线程放在池中,等需要使用的时候就从池中拿一个,这要比需要的时候创建一个线程对象要快的。 2、方便管理 可以编写线程池管理代码对池中的线程同一进行管理,比如说启动时有该程序...
  • CountDownLatch : CountDownLatch 用于阻塞当前 1 个或个线程,其目的是让这些线程等待其它线程的执行完成。 可以简单将其理解为一个计数器,当初始化一个 count=n 的 CountDownLatch 对象之后,需要调用该对象...
  • ThreadLocal原理及使用场景

    千次阅读 多人点赞 2022-01-02 19:56:01
    ThreadLocal ​ ThreadLocal意为线程本地变量,用于解决线程并发时访问共享变量的问题。 ​ 所谓的共享变量指的是在堆中的实例、静态属性和数组;...​ 很明显,在线程的场景下,当有个线程对共享
  • Redis使用场景

    千次阅读 多人点赞 2019-09-27 11:32:38
    文章目录计数器缓存会话缓存全页缓存(FPC)查找表消息队列(发布/订阅功能)分布式锁实现其它 计数器 可以对 String 进行自增自减运算,从而实现...可以使用 Redis 来统一存储台应用服务器的会话信息。 当应用服...
  • TreeMap使用场景 优势

    千次阅读 2020-03-21 10:05:47
    TreeMap使用场景 1- 简介 TreeMap的底层实现原理 基于红黑树实现的排序Map TreeMap增删改查的时间复杂度 TreeMap的增删改查和统计相关的操作的时间复杂度都为O(logn) TreeMap的key和value的要求 1 由于实现...
  • ZooKeeper使用场景

    万次阅读 2018-11-28 21:16:54
    网上对ZooKeeper的使用场景也有不少介绍,本文将结合作者身边的项目例子,系统的对zk的使用场景进行归类介绍。 值得注意的是,ZooKeeper并不是生来就为这些场景设计,都是后来众多开发者根据框架的...
  • 关于Unity使用多场景叠加的方法

    千次阅读 2020-09-16 11:47:08
    string[] _strSceneNmaes = { "scene1", "scene2", "scene3", "scene4", ... /// 场景加载 /// </summary> /// <param name="leveName"></param> public void LoadLevel(string leveName) ...
  • EventBus使用总结和使用场景

    千次阅读 2019-01-21 11:25:40
    一、EventBus介绍 EventBus是一个Android端优化的publish/subscribe消息总线,简化了应用程序内各组件间、组件与后台线程间的通信。传统的事件传递方式包括:Handler、...二、使用场景 刚开始接触EventBus的使用...
  • Elasticsearch最佳实践之使用场景

    万次阅读 多人点赞 2018-10-08 20:31:30
    本文围绕Elasticsearch的核心特征:搜索与分析,探讨其常见的业务场景:ELK日志系统、数据聚合分析、业务内搜索,以及集群建设的选择。
  • MQ 有哪些使用场景

    千次阅读 2020-05-26 22:18:19
    流量削峰:秒杀和抢购等场景经常使用 MQ 进行流量削峰。活动开始时流量暴增,用户的请求写入 MQ,超过 MQ 最大长度丢弃请求,业务系统接收 MQ 中的消息进行处理,达到流量削峰、保证系统可用性的目的。 日志处理
  • Redis 16 个常见使用场景

    万次阅读 多人点赞 2022-03-21 17:19:31
    这个场景最开始是是一篇介绍微博Redis应用的PPT中看到的,其中提到微博的Redis主要是用在在计数和好友关系两方面上,当时对好友关系方面的用法不太了解,后来看到《Redis设计与实现》中介绍到作者最开始去使用Redis...
  • Hbase常见的使用场景

    千次阅读 2022-02-03 21:41:44
    Hbase常见的使用场景
  • 什么是闭包 以及使用场景

    千次阅读 2022-05-02 21:33:51
    什么是闭包 以及作用场景
  • 一文读懂 HBase 使用场景

    万次阅读 2019-05-17 13:39:29
    目前已经在金融、交通、医疗、车联网、IoT等众多领域有了最佳实践,涉及到订单/账单存储、用户画像、时空/时序数据、对象存储、Cube分析等各个使用场景。 往期推荐 1、HBase最佳实践 | 聊聊HBase核心配置参数 2、...
  • Unity 使用多场景管理API加载卸载场景 SceneLoader.cs using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.SceneManagement; public class SceneLoader : ...
  • ACL:是什么?目的?使用场景

    万次阅读 多人点赞 2020-01-30 11:26:57
    访问控制列表ACL(Access Control List)是由一条或条规则组成的集合。所谓规则,是指描述报文匹配条件的判断语句,这些条件可以是报文的源地址、目的地址、端口号等。 ACL本质上是一种报文过滤器,规则是过滤器...
  • ConcurrentHashMap的使用场景

    千次阅读 2018-05-24 10:22:59
    读取快,插入慢,线程不安全LinkedHashMap:读取快,插入慢treeMap:排序concurrentHashMap:线程安全,支持高并发的操作当项目中的全局变量有线程操作时需要用concurrentHashMap,若只是单线程则可以使用hashmap。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,307,265
精华内容 922,906
关键字:

多场景使用