El grupo de subprocesos de Java se da cuenta de la función de pico

1. Introducción al grupo de subprocesos

Grupo de subprocesos (en inglés: grupo de subprocesos): es una forma de procesamiento de subprocesos múltiples en la que las tareas se agregan a la cola durante el procesamiento, y luego estas tareas se inician automáticamente después de que se crean los subprocesos. Los subprocesos del grupo de subprocesos son subprocesos en segundo plano. Cada subproceso usa el tamaño de pila predeterminado, se ejecuta con la prioridad predeterminada y está en una unidad de subprocesos múltiples. Si un subproceso está inactivo en el código administrado (como esperando un evento), el grupo de subprocesos insertará otro subproceso auxiliar para mantener ocupados a todos los procesadores. Si todos los subprocesos del grupo de subprocesos están siempre ocupados, pero la cola contiene trabajo pendiente, el grupo de subprocesos creará otro subproceso auxiliar después de un período de tiempo, pero el número de subprocesos nunca superará el máximo. Los subprocesos que superan el máximo se pueden poner en cola, pero no se iniciarán hasta que los demás subprocesos estén terminados.

Los siguientes son los materiales de aprendizaje que recopilé en Internet sobre el subproceso múltiple y el grupo de subprocesos de Java.

Materiales de aprendizaje 1: "Java Multithreading"

Materiales de aprendizaje 2: "ExecutorService del grupo de subprocesos Java"

Materiales de aprendizaje 3: "Clase de grupo de subprocesos Java ThreadPoolExecutor, ScheduledThreadPoolExecutor y clase de fábrica Executors"

Materiales de aprendizaje 4: "El grupo de subprocesos de Java se da cuenta de la función de aumento"

 

2. El grupo de subprocesos de Java realiza la función de aumento

[Ejemplo] Java usa multi-threading y Redis para lograr una instancia en la que 1000 personas matan 100 teléfonos móviles en segundos.

(1) Implementación de SecondKill (SecondKill.java): cree múltiples subprocesos y use la función de transacción de Redis para realizar la segunda función de eliminación.

package com.pjb.seckill;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
import java.util.List;

/**
 * 秒杀抢购
 * @author pan_junbiao
 **/
public class SecondKill implements Runnable
{

    String iphone = "iphone";
    Jedis jedis = new Jedis("127.0.0.1",6379);
    String userInfo;

    public SecondKill(String userInfo)
    {
        this.userInfo = userInfo;
    }

    @Override
    public void run()
    {
        try
        {
            jedis.watch(iphone); //watchkeys

            String val = jedis.get(iphone);
            int valint = Integer.valueOf(val);

            if(valint<=100 && valint>=1)
            {
                //1、使用MULTI命令开启事务
                Transaction tx = jedis.multi();

                //2、事务命令入队
                tx.incrBy("iphone",-1);

                //3、使用EXEC命令执行事务
                //提交事务。如果此时watchkeys被改动了，则返回null
                List<Object> list = tx.exec();

                if(list==null || list.size()==0)
                {
                    String failuserinfo = "fail_" + userInfo;
                    String failinfo = "用户：" + failuserinfo + "商品争抢失败，抢购失败";
                    System.out.println(failinfo);
                    //抢购失败业务逻辑
                    jedis.setnx(failuserinfo,failinfo);
                }
                else
                {
                    for(Object succ : list)
                    {
                        String succuserinfo = "succ_" + succ.toString() + "_" + userInfo;
                        String succinfo = "用户：" + succuserinfo + " 抢购成功，当前抢购成功人数：" + (1 -(valint -100));
                        System.out.println(succinfo);
                        //抢购成功业务逻辑
                        jedis.setnx(succuserinfo,succinfo);
                    }
                }
            }
            else
            {
                String failuserinfo = "kcfail_" + userInfo;
                String failinfo1 = "用户：" + failuserinfo + " 商品被抢购完毕，抢购失败";
                System.out.println(failinfo1);
                jedis.setnx(failuserinfo,failinfo1);
                //Thread.sleep(500);
                return;
            }
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
        finally
        {
            jedis.close();
        }
    }
}

(2) Programa principal (SecondKillTest.java): el programa de entrada de la función spike, que se utiliza para crear un grupo de subprocesos, generar ID de usuario al mismo tiempo, llamar al código de la función spike y completar la tarea spike.

package com.pjb.seckill;

import com.pjb.util.RedisHelper;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;

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

/**
 * Redis秒杀功能的实现，1000人抢购100部手机
 * @author pan_junbiao
 **/
public class SecondKillTest
{
    public static void main(String[] args)
    {
         RedisHelper redisHelper = new RedisHelper();

        final String iphone = "iphone";
        //20个线程池并发数
        ExecutorService executor = Executors.newFixedThreadPool(20);

        final Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.del(iphone); //先删除
        jedis.set(iphone,"100"); //设置起始的抢购数
        jedis.close();

        for(int i=0; i<1000; i++)
        {
            String userInfo = "pan_junbiao的博客" + i;
            executor.execute(new SecondKill(userInfo));
        }
        executor.shutdown();
    }
}

Resultados del:

 

3. El grupo de subprocesos de Java se da cuenta de la función de las tareas de tiempo

[Ejemplo] Java usa java.util.concurrent.ScheduledExecutorService para implementar tareas de sincronización.

package com.pjb.seckill;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 使用ScheduledExecutorService实现定时任务
 * @author pan_junbiao
 */
public class Task
{
    public static void main(String[] args)
    {
        //1、创建线程任务
        Runnable runnable = new Runnable()
        {
            public void run()
            {
                System.out.println("您好，欢迎访问 pan_junbiao的博客");
            }
        };

        //2、创建线程池
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();

        //3、线程池绑定线程任务并执行（第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间）
        service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);
    }
}

Resultados del: