精华内容
下载资源
问答
  • Thread提供了一个一个线程等待另一个线程执行完的方法——join();当线程A调用B线程join()方法后,线程A将会阻塞,只有等B线程执行完后在会执行线程A public class ThreadMain { public static void main...

    如何保证多个线程同时执行

    CountDownLatch是一个计数器闭锁,主要的功能就是通过await()方法来阻塞住当前线程,然后等待计数器减少到0了,向下减计数器的方法:countdown()。

    public class Demo1 {
    
        public static void main(String[] args) {
            int threadCount = 3;
            //计数器设置为1
            CountDownLatch countDownLatch = new CountDownLatch(1);
            for (int i = 0; i < threadCount; i++) {
                new Thread(() -> {
                    try {
                        //阻塞
                        countDownLatch.await();
                        System.out.println(Thread.currentThread().getName() + "线程开始时间:" + System.currentTimeMillis());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }).start();
            }
            System.out.println("计数器减一,变成0,开始执行三个子线程");
            countDownLatch.countDown();
            
            try {
                Thread.sleep(5000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("主线程执行结束");
        }
    }

    执行结果如下:

    可以看到三个线程开始时间一直(可能会有纳米级的误差)。

     

    如何保证多个线程在并发下依次执行

    使用volatile 和 static来标记一个变量,实现demo如下:

    public class Demo2 {
    
        private volatile static int flag = 1;
    
        public static void main(String[] args) {
            Thread th1 = new Thread(() -> {
                    while (true) {
                        if (flag == 1) {
                            try {
    //                            Thread.sleep(1000L);
                                System.out.println("执行线程" + Thread.currentThread().getName() + "业务");
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            flag = 2;
                            return;
                        }
    
                    }
            });
    
            Thread th2 = new Thread(() -> {
                while (true) {
                    if (flag == 2) {
                        try {
    //                        Thread.sleep(1000L);
                            System.out.println("执行线程" + Thread.currentThread().getName() + "业务");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        flag = 3;
                        return;
                    }
    
                }
            });
    
            Thread th3 = new Thread(() -> {
                while (true) {
                    if (flag == 3) {
                        try {
    //                        Thread.sleep(1000L);
                            System.out.println("执行线程" + Thread.currentThread().getName() + "业务");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        flag = 1;
                        return;
                    }
                }
            });
    
            th1.start();
            th2.start();
            th3.start();
    
        }
    }

    结果如下:

    这里flag必须要用volatile修饰

    如何保证多个线程有序交错执行

    使用Semaphore 类;

    public class Demo3 {
    
        //设置信号量为1
        private static Semaphore semaphore1 = new Semaphore(1);
        private static Semaphore semaphore2 = new Semaphore(1);
        private static Semaphore semaphore3 = new Semaphore(1);
    
        public static void main(String[] args) {
            int size = 10;
    
            try {
                //获取信号量,当被获取后不释放将会卡住
                semaphore2.acquire();
                semaphore3.acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            Thread th1 = new Thread(() -> {
                for (int i = 0; i < size; i++) {
                    try {
                        //第一次进来由于2和3被获取了,其他线程被卡住,所以这里能获取到
                        semaphore1.acquire();
                        System.out.println("执行线程" + Thread.currentThread().getName() + "业务");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //释放第二个信号量
                    semaphore2.release();
                }
            });
    
            Thread th2 = new Thread(() -> {
                for (int i = 0; i < size; i++) {
                    try {
                        semaphore2.acquire();
                        System.out.println("执行线程" + Thread.currentThread().getName() + "业务");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    semaphore3.release();
                }
            });
    
            Thread th3 = new Thread(() -> {
                for (int i = 0; i < size; i++) {
                    try {
                        semaphore3.acquire();
                        System.out.println("执行线程" + Thread.currentThread().getName() + "业务");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    semaphore1.release();
                }
            });
    
            th1.start();
            th2.start();
            th3.start();
    
        }
    }

    结果可看到几个线程是依次轮询执行:

    Semaphore并不控制线程之间的关系;它表示的是一个可使用资源的数目,如上new Semaphore(1),则表示创建资源数为1,当调用acquire()方法后,资源数为0,当有其他线程再次调用acquire()时,因为这时没有资源了,所以这里会卡住住,等到调用release()方法后,归还资源,其他线程才会去执行。它也被更多地用来限制流量,类似阀门的功能。

    展开全文
  • 多线程是同时执行多个线程的吗

    千次阅读 2020-03-26 18:25:50
    解释1:当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程...

    相信多线程各位大佬都用过,不管是在单核cpu还是多核cpu上都可以执行,但是多线程是同时执行多个线程的吗?

    并发和并行:

    并发:

    解释1:当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程处于挂起状。.这种方式我们称之为并发(Concurrent)。
    解释2:对于单核cpu来说,多线程并不是同时进行的,操作系统将时间分成了多个时间片,大概均匀的分配给线程,到达某个线程的时间段,该线程运行,其余时间待命,这样从微观上看,一个线程是走走停停的,宏观感官上,在某一时刻似乎所有线程都在运行。并发是针对时间片段来说的,在某个时间段内多个线程处于runnable到running之间,但每个时刻只有一个线程在running,这叫做并发。(系统不断地在各个线程之间来回的切换,因为系统切换的速度非常的快,所以给我们在同时运行的错觉)

    并行:当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时,另一个CPU可以执行另一个线程,两个线程互不抢占CPU资源,可以同时进行,这种方式我们称之为并行(Parallel)。

    区别:并发和并行是即相似又有区别的两个概念,并行是指两个或者多个事件在同一时刻发生;而并发是指两个或多个事件在同一时间间隔内发生。在多道程序环境下,并发性是指在一段时间内宏观上有多个程序在同时运行,但在单处理机系统中,每一时刻却仅能有一道程序执行,故微观上这些程序只能是分时地交替执行。倘若在计算机系统中有多个处理机,则这些可以并发执行的程序便可被分配到多个处理机上,实现并行执行,即利用每个处理机来处理一个可并发执行的程序,这样,多个程序便可以同时执行。

     

    结论:

    单核cpu是系统将时间分割成时间段交由不同的线程执行,所以实际单核cpu同一时间是只存在一个线程的。

    多核cpu可以理解为多个单核cpu,一个cpu执行一个线程,其他cpu也可以执行其他线程,所以多核cpu是可以同时执行多个线程。

     

    展开全文
  • 我一直不太明白,多线程是指多个线程同时执行多个任务 还是指多个线程同时执行一个任务?求解。如果执行 同一个任务肯定要加锁。
  • Java 多线程同时执行

    万次阅读 2016-01-08 10:07:48
    Java 多线程同时执行

        我们创建三个任务与三个线程,让三个线程启动,同时执行三个任务。

        任务类必须实现 Runable 接口,而 Runable 接口只包含一个 run 方法。需要实现

    这个方法来告诉系统线程将如何运行。

        创建任务:

        TaskClass task = new TaskClass(...);

        任务必须在线程中执行,创建线程:

        Thread thread = new Thread(task);

        然后调用 start 方法告诉 Java 虚拟机该线程准备运行,如下:

        thread.start();

        下面的程序创建三个任务和三个运行这些任务的线程:

    任务1 打印字母 a 10次

    任务2 打印字母 b 10次

    任务3 打印 1 ~ 10  的整数

    运行这个程序,则三个线程共享CPU,在控制台上轮流打印字母和数字。

    代码:

    public class TaskDemo {
    
    	public static void main(String[] args) {
    		//创建三个任务
    		Runnable printA = new PrintChar('a', 10);
    		Runnable printB = new PrintChar('b', 10);
    		Runnable print100 = new PrintNum(10);
    		//创建三个线程
    		Thread thread1 = new Thread(printA);
    		Thread thread2 = new Thread(printB);
    		Thread thread3 = new Thread(print100);
    		//启动三个线程,将同时执行创建的三个任务
    		thread1.start();
    		thread2.start();
    		thread3.start();
    	}
    }
    //此任务将一个字符打印指定次数
    class PrintChar implements Runnable {
    
    	private char charToPrint;
    	private int times;
    	//构造函数
    	public PrintChar(char charToPrint, int times) {
    		this.charToPrint = charToPrint;
    		this.times = times;
    	}
    	//重写接口Runable中的run方法,告诉系统此任务的内容
    	@Override
    	public void run() {
    		for (int i = 0; i < times; i++) {
    			System.out.print(charToPrint);
    		}
    	}
    }
    //此任务打印1~n
    class PrintNum implements Runnable {
    	private int lastNum;
    	
    	public PrintNum(int lastNum) {
    		this.lastNum = lastNum;
    	}
    
    	@Override
    	public void run() {
    		for (int i = 0; i < lastNum; i++) {
    			System.out.print(" " + i);
    		}
    	}
    }

    结果:

    注意:每次运行的结果都不相同,因为我们并不知道三个任务的执行顺序。

    展开全文
  • public class ThreadName extends Thread{ ...System.out.println("线程:"+this.getName());//打印线程名字 } public static void main(String[] args) { // TODO Auto-generated method stub
    public class ThreadName extends Thread{
    

    public void run()
    {
    System.out.println("线程:"+this.getName());//打印线程名字
    }


    public static void main(String[] args) {
    // TODO Auto-generated method stub
    ThreadName thread1=new ThreadName();//创建线程
    ThreadName thread2=new ThreadName();
    ThreadName thread3=new ThreadName();
    thread1.setName("1号");//设置线程名字
    thread2.setName("2号");
    thread3.setName("3号");
    thread1.start();//执行线程
    thread2.start();
    thread3.start();
    }


    }
    展开全文
  • Android中让多个线程顺序执行探究

    千次阅读 2015-09-14 10:27:15
    前言: 不知道从什么时候开始,越来越喜欢把平时学到的一些东西...对于这种问题,我更的是把写博客看成自己技术的总结,因为你总结一技术,肯定是需要查大量资料,而在此过程中你不仅巩固了以前的知识也会不断的
  • 这个题目其实就是指定多个线程的执行顺序,基本思路如下: 设定一个orderNum,每个线程执行结束之后,更新orderNum,指明下一个要执行的线程。并且唤醒所有的等待线程。 在每一个线程的开始,要while判断...
  • 多核CPU并不能进程的线程同时执行
  • 如何让多个线程按照顺序执行

    千次阅读 2018-10-12 19:21:20
     如果有a,b,c三个线程,我们依次执行这三个线程。因为不保证有序性,可能执行出来是混乱的 解决如下: 第一种使用join()方法,这个方法的作用是,当前执行线程等待直到调用join方法的线程结束运行 代码如下:...
  • java多个线程同时启动的两种方式

    万次阅读 2019-01-23 21:54:55
    【背景】今天遇到一个并发问题,为了在开发环境复现这个bug,需要让多个线程同时执行到某条语句。 【解决方案】 java1.5的concurrent包下的CyclicBarrier 和 CountDownLatch都能解决这个问题。不得不佩服Doug Lea! ...
  • Python之多线程:python多线程设计之同时执行多个函数命令详细攻略 目录 实现功能 采取方法 应用场景 实现功能 同时执行多个函数命令 采取方法 T1、单个实现 import threading threading....
  • import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService;... * 要求实现10个线程同时执行,并通知比赛结束 * 使用到的类有: * 1:CountDownLatch,如其...
  • java线程如何个线程执行一次?我目前只能是检测到getname()然后用wait()方法。想知道还有没其他方法? ``` public class TicketSale { public static void main(String[] args) { ...
  • 博主昨天去一家公司面试,被面试官问到一个问题,如果开启10个线程,但是需要这10个线程执行完成后,再交由主线程统一输入,如何实现?当时我没有回答,我对线程并不是那么的熟悉,面试结束后,我通过查阅资料...
  • 问题最近我在处理一批数据,用多线程来处理,我想知道大概多久能处理完。比如我先用多线程处理 100 条数据,统计下用时,然后根据总的数据量就可以大概估算出处理完这批数据要多久。使用 CountDownLatch 计时思路:...
  • java2个线程交替执行,每个线程执行1秒: package tf56.SpringBoot.Annotation; /** * Created by Administrator on 2017/10/17. */ public class Test2 { private static int state = 1; public static ...
  • quartz定时器同时执行两次,多线程同时执行
  • 个线程执行多个任务,要按照顺序执行import java.util.concurrent.ArrayBlockingQueue;/** * 一个线程执行多个任务,要按照顺序执行,怎么去实现? * 分析: * 多个人任务-->线程 * 要按照顺序执行--》就需要...
  • 如果想同时执行while True循环,可以使用多线程threading来实现。完整代码#coding=gbkfrom time import sleep, ctime import threadingdef muisc(func): while True: print 'Start playing: %s! %s' %(func,...
  • python多进程多线程,多个程序同时运行

    千次阅读 多人点赞 2021-04-08 13:47:15
    python 多线程 多进程同时运行 多任务要求 python 基础语法 python 文件目录操作 python 模块应用 开发工具 pycharm ...在一段时间内交替执行多个任务, 例如单核cpu 处理多任务, 操作系统各个任务交
  • 如上所述:启动代理池时发现需要同时启动两py文件,但是每次去找到两不再同一位置的文件然后启动它们特别麻烦。 于是,我想在一py文件中进行代理池调用的集成。 在启动这代理池时遇...
  • 高并发模拟~多个线程同时发起请求

    千次阅读 2019-07-09 23:30:10
    CountDownLatch:计数器,一个线程或多个线程一直等待,直到其他线程执行的操作完成。 1、CyclicBarrier 适用在多线程相互等待,直到到达一个屏障点。并且CyclicBarrier是可重用的。 下面的列子,设置线程阻塞200...
  • 关于多个线程同时调用单例模式的对象,该对象中方法的局部变量是否会受多个线程的影响 对于那些会以多线程运行的单例类,例如Web应用中的Servlet,每个方法中对局部变量的操作都是在线程自己独立的内存区域内完成的...
  • JAVA多线程实现多个线程同时运行

    千次阅读 2019-09-18 05:32:44
    * 多个线同时运行 * CyclicBarrier */ public class CyclicBarrierDemo { private static CyclicBarrier cyclicBarrier = new CyclicBarrier(5); public static void main(String[] args) { ExecutorService ...
  • 如何确保三个线程顺序执行

    万次阅读 多人点赞 2018-07-03 09:42:00
    确保三个线程t1执行完后t2执行,t2执行完成后t3执行。1.使用join1.使用join thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法,直到...
  • 让多线程按顺序执行的几种方法

    万次阅读 2019-09-05 14:23:58
    文章介绍4种方法,简单易懂,通过4demo抛砖引玉。 目录 在子线程中通过join()方法指定顺序 在主线程中通过join()方法指定顺序 ...通过join()方法使当前线程“阻塞”,等待指定线程执行完毕后继续执行。举例:在...
  • 最近有线上发现一个bug:多个业务场景并行请求,出现下发结果存在串的现象。 一、现象描述 如下图所示:两个不同策略出现串的情况 ...顺序执行,指的是测试计划中存在多个线程组时,第一个线程组执行完后再...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,453,451
精华内容 581,380
关键字:

如何让多个线程同时执行