多线程执行

已于 2023-06-21 11:53:48 修改
阅读量196 收藏 1
点赞数
分类专栏： 多线程 文章标签： java 数学建模 算法
于 2023-06-21 11:52:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yearraey/article/details/131296427
版权

一、交互执行abc

1、队列+park+volatile

    private static LinkedList<Thread> list = new LinkedList<>();
    private static volatile Boolean state = new Boolean(false);

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            while (true) {
                LockSupport.park();
                System.out.println("a");
                state = new Boolean(true);
            }
        });
        thread1.start();
        list.add(thread1);
        
        Thread thread2 = new Thread(() -> {
            while (true) {
                LockSupport.park();
                System.out.println("b");
                state = new Boolean(true);
            }
        });
        thread2.start();
        list.add(thread2);

        Thread thread3 = new Thread(() -> {
            while (true) {
                LockSupport.park();
                System.out.println("c");
                state = new Boolean(true);
            }
        });
        thread3.start();
        list.add(thread3);

        while (true) {
            Thread take = list.poll();
            LockSupport.unpark(take);
            while (true) {
                if (state.booleanValue() == true) {
                    state = new Boolean(false);
                    list.add(take);
                    break;
                }
            }
        }
    }

二、一个打印偶数一个打印奇数

1、synchronized

    private static final Object lock = new Object();
    private static int num = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "=" + num++);
                        lock.notifyAll();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });


        Thread thread2 = new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    try {
                        System.out.println(Thread.currentThread().getName() + "=" + num++);
                        lock.notifyAll();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread1.start();
        thread2.start();

2、Exchanger（两个线程无序）

private static Exchanger<Integer> exchanger = new Exchanger<>();

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            Integer num = -1;
            while (true) {
                try {
                    num = num + 2;
                    Integer exchange = exchanger.exchange(num);
                    System.out.println(Thread.currentThread().getName() + "=" + exchange);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });


        Thread thread2 = new Thread(() -> {
            Integer num = -2;
            while (true) {
                try {
                    num = num + 2;
                    Integer exchange = exchanger.exchange(num);
                    System.out.println(Thread.currentThread().getName() + "=" + exchange);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();
        thread2.start();


    }

三、按照顺序，三个线程分别打印A5次，B10次，C15次

1、synchronized

private static int flag = 1;
    private static Object lock = new Object();

    public static void main(String[] args) {


        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                while (true) {
                    try {
                        if (flag == 1) {
                            for (int i = 0; i < 5; i++) {
                                System.out.println("A");
                            }
                            flag++;
                        }
                        lock.notifyAll();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                while (true) {
                    try {
                        if (flag == 2) {
                            for (int i = 0; i < 10; i++) {
                                System.out.println("B");
                            }
                            flag++;
                        }
                        lock.notifyAll();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread thread3 = new Thread(() -> {
            synchronized (lock) {
                while (true) {
                    try {
                        if (flag == 3) {
                            for (int i = 0; i < 15; i++) {
                                System.out.println("C");
                            }
                            flag = 1;
                        }
                        lock.notifyAll();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread1.start();
        thread2.start();
        thread3.start();
    }

2、lock

static volatile int flag = 1;

    public static void main(String[] args) {

        Lock lock = new ReentrantLock();
        Condition c1 = lock.newCondition();
        Condition c2 = lock.newCondition();
        Condition c3 = lock.newCondition();


        Thread thread1 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    if (flag != 1) {
                        c1.await();
                    }
                    for (int i = 0; i < 5; i++) {
                        System.out.println("A");
                    }
                    flag = 2;
                    c2.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    if (flag != 2) {
                        c2.await();
                    }
                    for (int i = 0; i < 10; i++) {
                        System.out.println("B");
                    }
                    flag = 3;
                    c3.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });

        Thread thread3 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    if (flag != 3) {
                        c3.await();
                    }
                    for (int i = 0; i < 15; i++) {
                        System.out.println("C");
                    }
                    flag = 1;
                    c1.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        thread1.start();
        thread2.start();
        thread3.start();
    }

四、创建水分子

 private static Lock lock = new ReentrantLock();
    private static Condition c1 = lock.newCondition();
    private static Condition c2 = lock.newCondition();
    private static int num = 1;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    if (num == 3) {
                        c2.signal();
                        c1.await();
                    }
                    System.out.print("H" + "--------" + num);
                    num++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    if (num != 3) {
                        c1.signal();
                        c2.await();
                    }
                    System.out.println("O" + "--------" + num);
                    num = 1;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        });
        thread1.start();
        thread2.start();
    }

五、生产者，消费者

1、Disruptor

public static void main(String[] args) {
        EventFactory<Message> factory = new MessageFactory();

        int ringBufferSize = 1024 * 1024;

        Disruptor<Message> disruptor =

                new Disruptor<Message>(factory, ringBufferSize, Executors.defaultThreadFactory(), ProducerType.SINGLE, new YieldingWaitStrategy());

        disruptor.handleEventsWith(new MessageHandler("handler-1")).then(new MessageHandler("handler-2"), new MessageHandler("handler-3"));

        disruptor.start();

        RingBuffer<Message> ringBuffer = disruptor.getRingBuffer();

        Producer producer = new Producer(ringBuffer);

        //单生产者，生产3条数据

        for (int l = 0; l < 3; l++) {

            producer.onData(l + "");

        }


        disruptor.shutdown();

    }

    static class Producer {

        private RingBuffer<Message> ringBuffer;

        public Producer(RingBuffer<Message> ringBuffer) {
            this.ringBuffer = ringBuffer;
        }

        public void onData(String text) {
            long next = this.ringBuffer.next();
            Message message = ringBuffer.get(next);
            message.setId(UUID.randomUUID().toString());
            message.setText("信息" + text);
            ringBuffer.publish(next);
        }

    }


    static class MessageHandler implements EventHandler<Message> {

        String handlerName;

        public MessageHandler(String handlerName) {
            this.handlerName = handlerName;
        }

        @Override
        public void onEvent(Message message, long l, boolean b) {
            message.addHandler(handlerName + "已经处理");
            System.out.println("消息:" + message.getText() + "  " + handlerName + "已经处理");
        }
    }

    static class MessageFactory implements EventFactory<Message> {

        @Override
        public Message newInstance() {
            return new Message();
        }
    }

    static class Message {
        String id;
        String text;
        List<String> handler = new ArrayList<>();

        public String getId() {
            return id;
        }

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

        public String getText() {
            return text;
        }

        public void setText(String text) {
            this.text = text;
        }

        public List<String> getHandler() {
            return handler;
        }

        public void setHandler(List<String> handler) {
            this.handler = handler;
        }

        public void addHandler(String handler) {
            this.handler.add(handler);
        }
    }

2、LinkedBlockingQueue

static Random random = new Random();
    static LinkedBlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<String>(5);

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                while (true) {
                    String value = String.valueOf(random.nextInt(10));
                    System.out.println("生产者1生产了——————" + value);
                    linkedBlockingQueue.put(value);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                while (true) {
                    String take = linkedBlockingQueue.take();
                    System.out.println("消费了" + take);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
    }

3、synchronized 

static int len = 10;
    static Random random = new Random();
    static Queue<String> queue = new LinkedList<String>();


    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                while (true) {
                    synchronized (queue) {
                        if (queue.size() == len) {
                            System.out.println("当前队列满");
                            queue.notifyAll();
                            queue.wait();
                        }
                        queue.notifyAll();
                        String value = String.valueOf(random.nextInt(10));
                        System.out.println("生产者1生产了——————" + value);
                        queue.add(value);
                        Thread.yield();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                while (true) {
                    synchronized (queue) {
                        if (queue.size() == 0) {
                            System.out.println("当前队列为空");
                            queue.notifyAll();
                            queue.wait();
                        }
                        queue.notifyAll();
                        String take = queue.poll();
                        System.out.println("消费了" + take);
                        Thread.yield();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
    }

4、Lock

static int len = 10;
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    static Random random = new Random();
    static Queue<String> queue = new LinkedList<>();


    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                while (true) {
                    lock.lock();
                    try {
                        if (queue.size() == len) {
                            System.out.println("当前队列满");
                            condition.await();
                        }
                        String value = String.valueOf(random.nextInt(10));
                        System.out.println("生产者1生产了——————" + value);
                        queue.add(value);
                        condition.signal();
                    } finally {
                        lock.unlock();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                while (true) {
                    lock.lock();
                    try {
                        if (queue.size() == 0) {
                            System.out.println("当前队列为空");
                            condition.await();
                        }
                        String take = queue.poll();
                        System.out.println("消费了" + take);
                        condition.signal();
                    } finally {
                        lock.unlock();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
    }

5、Semaphore

static Semaphore notFull = new Semaphore(10);
    static Semaphore notEmpty = new Semaphore(0);
    
    static Random random = new Random();
    static Queue<String> queue = new ConcurrentLinkedQueue<>();


    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            while (true) {
                try {
                    notFull.acquire();
                    String value = String.valueOf(random.nextInt(10));
                    System.out.println("生产者1生产了——————" + value);
                    queue.add(value);
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    notEmpty.release();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                while (true) {
                    try {
                        notEmpty.acquire();
                        String take = queue.poll();
                        System.out.println("消费了" + take);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }finally {
                        notFull.release();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        thread1.start();
        thread2.start();
    }

6、管道

static PipedOutputStream pipedOutputStream = new PipedOutputStream();
    static PipedInputStream pipedInputStream = new PipedInputStream();

    static Random random = new Random();


    public static void main(String[] args) throws IOException {
        Thread thread1 = new Thread(() -> {
            while (true) {
                try {
                    String value = String.valueOf(random.nextInt(10));
                    System.out.println("生产者1生产了——————" + value);
                    pipedOutputStream.write(value.getBytes(StandardCharsets.UTF_8));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                while (true) {
                    try {
                        int length = -1;
                        byte[] buffer = new byte[64];
                        while ((length = pipedInputStream.read(buffer)) != -1) {
                            System.out.println("消费了" + new String(buffer, 0, length));
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        pipedOutputStream.connect(pipedInputStream);

        thread1.start();
        thread2.start();
    }

六、100个任务，分10批次，10批串行执行，10个任务并行执行

1、CyclicBarrier

批次之间结果无依赖，无返回值

public class Test {

    static ExecutorService service = new ThreadPoolExecutor(200, 400, 30, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(2000), new ThreadFactoryBuilder().setNameFormat("thread-%d").build());

    static CyclicBarrier cyclicBarrier = new CyclicBarrier(10);

    public static void main(String[] args) {

        List<Runnable> lists = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                String str = "批次:" + i + " " + "任务:" + j;
                Runnable runnable = () -> {
                    try {
                        System.out.println(str);
                        cyclicBarrier.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                };
                lists.add(runnable);
            }
        }
        lists.forEach(service::execute);
    }
}

2、stream

static ExecutorService executor = new ThreadPoolExecutor(200, 400, 30, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(2000), new ThreadFactoryBuilder().setNameFormat("thread-%d").build());

    public static void main(String[] args) {

        List<List<Callable<String>>> lists = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            List<Callable<String>> list = new ArrayList<>();
            for (int j = 0; j < 10; j++) {
                String str = "批次:" + i + " " + "任务:" + j;
                Callable<String> callable = () -> {
                    System.out.println(str);
                    return str;
                };
                list.add(callable);
            }
            lists.add(list);
        }
        List<String> listStream = lists.stream().map(s -> {
            try {
                return executor.invokeAll(s);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }).map(t -> t.parallelStream().map(fu -> {
            try {
                return fu.get();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }).collect(Collectors.toList())).flatMap(Collection::stream).collect(Collectors.toList());
    }

3、CompletableFuture

public static void main(String[] args) {
        CompletableFuture<Void> future = new CompletableFuture<Void>();
        for (int i = 0; i < 10; i++) {
            CompletableFuture<Void>[] completableFutures = new CompletableFuture[10];
            for (int j = 0; j < 10; j++) {
                String str = "批次:" + i + " " + "任务:" + j;
                completableFutures[j] = CompletableFuture.runAsync(() -> System.out.println(str));
            }
            CompletableFuture<Void> allOf = CompletableFuture.allOf(completableFutures);
            future.thenRun(() -> {
                try {
                    allOf.get();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        try {
            future.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4、Queue

    static ExecutorService executor = new ThreadPoolExecutor(200, 400, 30, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(2000), new ThreadFactoryBuilder().setNameFormat("thread-%d").build());

    public static void main(String[] args) {
        Queue<Queue<Callable<String>>> queues = new LinkedList<>();
        for (int i = 0; i < 10; i++) {
            Queue<Callable<String>> queue = new LinkedList<>();
            for (int j = 0; j < 10; j++) {
                String str = "批次:" + i + " " + "任务:" + j;
                Callable<String> callable = () -> {
                    System.out.println(str);
                    return str;
                };
                queue.add(callable);
            }
            queues.add(queue);
        }
        try {
            while (!queues.isEmpty()) {
                Queue<Callable<String>> poll = queues.poll();
                List<Future<String>> futureList = executor.invokeAll(poll);
                List<String> list = futureList.parallelStream().map(t -> {
                    try {
                        return t.get();
                    } catch (Exception e) {
                        e.printStackTrace();
                        return null;
                    }
                }).collect(Collectors.toList());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

5、lmax.disruptor

public class Test15 {

    static ExecutorService service = new ThreadPoolExecutor(200, 400, 30, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(2000), new ThreadFactoryBuilder().setNameFormat("thread-%d").build());

    public static void main(String[] args) {
        EventFactory<Queue<Runnable>> factory = new MessageFactory();

        int ringBufferSize = 1024 * 1024;

        Disruptor<Queue<Runnable>> disruptor =

                new Disruptor<Queue<Runnable>>(factory, ringBufferSize, Executors.defaultThreadFactory(), ProducerType.SINGLE, new YieldingWaitStrategy());
        

        disruptor.handleEventsWith(new MessageHandler("handler-1"))
                .then(new MessageHandler("handler-2"))
                .then(new MessageHandler("handler-3"))
                .then(new MessageHandler("handler-4"))
                .then(new MessageHandler("handler-5"))
                .then(new MessageHandler("handler-6"))
                .then(new MessageHandler("handler-7"))
                .then(new MessageHandler("handler-8"))
                .then(new MessageHandler("handler-9"))
                .then(new MessageHandler("handler-10"));

        disruptor.start();

        RingBuffer<Queue<Runnable>> ringBuffer = disruptor.getRingBuffer();

        Producer producer = new Producer(ringBuffer);


        Queue<Runnable> queues = new LinkedList<>();
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                String str = "批次:" + i + " " + "任务:" + j;
                Runnable runnable = () -> {
                    System.out.println(str);
                };
                queues.add(runnable);
            }
        }
        producer.onData(queues);

        disruptor.shutdown();

    }

    static class Producer {

        private RingBuffer<Queue<Runnable>> ringBuffer;

        public Producer(RingBuffer<Queue<Runnable>> ringBuffer) {
            this.ringBuffer = ringBuffer;
        }

        public void onData(Queue<Runnable> runnable) {
            long next = this.ringBuffer.next();
            Queue<Runnable> runnables = ringBuffer.get(next);
            runnables.addAll(runnable);
            ringBuffer.publish(next);
        }

    }


    static class MessageHandler implements EventHandler<Queue<Runnable>> {

        String handlerName;

        public MessageHandler(String handlerName) {
            this.handlerName = handlerName;
        }

        @Override
        public void onEvent(Queue<Runnable> runnables, long l, boolean b) throws Exception {
            for (int i = 0; i < 10; i++) {
                service.submit(runnables.poll()).get();
            }
        }
    }

    static class MessageFactory implements EventFactory<Queue<Runnable>> {

        @Override
        public Queue<Runnable> newInstance() {
            return new LinkedList<>();
        }
    }
}

无聊的陈
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程详解
m0_49008761的博客
08-26 586
多线程详解
Java多线程执行单个大任务
Staba的博客
11-04 1804
最近对一个接口执行进行优化，先简单说说接口的详情以及优化的方向吧。本文所提供的解决方法并不是一个好方案，但是本文的目的是在解决问题的同时，加深对线程池的了解与使用。该接口的主要工作内容是生成业务相关的图表（根据用户选择，可以生成1-n张图表），用户提交生成任务之后，便生成一个任务记录，初始状态为创建，用户将等待任务处理。任务状态有以下几种：创建、运行、失败、空数据、成功等，任务状态的变化将由任务执行情况而定。在用户提交生成任务之后，会将生成图表的任务提交到线程池中去执行。
Java学习篇 -- 多线程笔记（带你看不一样的多线程~）
最新发布
2401_84047990的博客
05-15 769
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
保证多线程顺序执行，四种方案，你知道几种？
u011220840的博客
08-03 2139
上周一位同学在面试中遇到了这么一道问题：有三个线程T1、T2、T3，如何保证顺序执行？常规操作，启动三个线程，让其执行。调用三个线程的start方法，很明显是按照顺序调用的，但是每次运行出来的结果，基本上都不相同，随机性特别强。怎么办呢？下面我们使用四种方案来实现。
并发编程(多线程)
zyx22334的博客
01-13 6013
标准库中的Timer类中有两个参数:1)Runnable2)时间dalay(就是多久之后完成Runnable中的任务)timer.schedule(安排)使用其功能.功能:1.能够让任务在指定的时间得到执行2.一个定时器可以注册N个任务,N个任务可以按照最初约定的时间,按顺序执行.根据任务我们能得出结论:1.我么需要一个线程扫描,负责判断时间是否到了/并执行任务.2.还需要一个数据结构,来保存所有注册的任务.
JAVA之多线程
你有看到我的史迪熊吗.
02-20 933
进程与线程进程：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。线程：线程可以理解为进程中的执行的一段程序片段，是进程的一个执行单元，是进程内可调度实体，是比进程更小的独立运行的基本单位，线程也被称为轻量级进程。一个程序至少一个进程，一个进程至少一个线程。
易语言多线程执行任务例程
06-02
在这个“易语言多线程执行任务例程”中，我们将深入探讨如何在易语言中利用多线程技术来提升程序的运行效率和并发能力。 多线程是现代计算机编程中的一个重要概念，它允许一个程序同时执行多个任务，从而充分利用...
多线程执行任务具体实现
04-07
本篇文章将深入探讨多线程执行任务的具体实现方式。 一、线程的概念与优势 线程是操作系统分配CPU时间的基本单元，一个进程可以包含一个或多个线程。相比于单线程，多线程能充分利用多核处理器资源，减少程序等待I/...
C#多线程执行
02-01
本篇文章将深入探讨C#中的多线程执行，并结合“TaskSortRelationArrange”这个文件名，推测其可能涉及到的任务排序与关系安排。 一、C#多线程基础 C#中的多线程主要依赖于System.Threading命名空间，其中Thread类是...
Concurrent.Thread.js多线程执行大批量函数
12-03
介绍了一个可以在JavaScript中应用多线程的库：Concurrent.Thread，内有多线程库脚本，以及使用说明和实例，如果查看详情，可以查看我的博客https://blog.csdn.net/hsl_1990_08_15/article/details/84765772
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
多线程并发执行任务
08-11
NULL 博文链接：https://mammahao.iteye.com/blog/2226890
多线程&并发篇
qq1226546902的博客
03-17 1115
Java中的多线程
多线程的使用
Zhang_hao_r的博客
12-28 649
一：进程与线程 进程： 1. 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的。 2.当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。进程就可以视为程序的一个实例。 3.大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全...
多线程相关的三组概念
ღ
11-19 167
程序和进程 程序（program）：一个固定的运行逻辑和数据的集合，是一个静态的状态，一般存储在硬盘中 进程（process）：一个正在运行的程序，是一个程序的一次运行，是一个动态的概念，一般存储在内存中。 例如：ctrl + shift + esc，打开任务管理器可以看到所有进程 进程和线程 进程（process）：一个正在执行的程序，有自己独立的资源分配，是一个独立的资源分配...
Java 多线程执行任务
LZHH_2008的博客
12-22 490
多线程使用例子
Java 多线程详解
wml_JavaKill的博客
02-02 323
多线程详解
使用多线程来执行任务，最终将结果汇总
张火火博客
11-08 2808
第一种 ：future.get();因为是按照提交顺序返回结果的，所以会造成阻塞。第二种：completionService.take().get()；是按谁完成谁先返回结果，放到一个队列里再取数据，只会在取数据时没有数据的时候阻塞。记得还有其他的实现方式，也是根据future来返回结果。实现callable接口。
java for 多线程执行
04-10
Java中的多线程执行是指在一个程序中同时执行多个线程，以提高程序的并发性和效率。Java提供了多种方式来实现多线程执行，包括以下几种常用的方法： 1. 继承Thread类：创建一个继承自Thread类的子类，并重写其run()...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值