精华内容
下载资源
问答
  • 2018-08-27 17:06:17

    在方法的外部申请一个这样的变量
    CountdownEvent latch = new CountdownEvent(3);
    比如现在执行的是方法a
    public void a()
    {
    int si=0,ei=0;
    Thread thread = new Thread(() => refreshData(si, ei));
    thread .start();
    thread = new Thread(() => refreshData(si, ei));
    thread .start();
    thread = new Thread(() => refreshData(si, ei));
    thread .start();
    latch.Wait();
    MessageBox.Show(start.ToString() + “,,,” + end.ToString());
    }
    private void refreshData(int start, int end)
    {
    latch.Signal();
    }
    这样会等到三个线程全部执行完后才会出现 messagebox提示框,

    更多相关内容
  • 新写自己的Threading类class MyThread(threading.Thread):#我的Thread类 判断流程结束没 用于os shell命令是否执行判断def __init__(self,func = ""):#输入待执行函数名 我执行的函数没有参数就没有加args输入了...

    新写自己的Threading类

    class MyThread(threading.Thread):#我的Thread类 判断流程结束没 用于os shell命令是否执行判断

    def __init__(self,func = ""):#输入待执行函数名 我执行的函数没有参数就没有加args输入了

    threading.Thread.__init__(self)

    self.func = func

    self.result = 1#未完成为1 标志位

    # 调用start自动执行的函数

    def run(self):

    self.result = self.func()

    self.result = 0#完成返回0

    然后执行

    class MyThread(threading.Thread):#我的Thread类 判断流程结束没 用于os shell命令是否执行判断

    def __init__(self,func = ""):#输入待执行函数名 我执行的函数没有参数就没有加args输入了

    threading.Thread.__init__(self)

    self.func = func

    self.result = 1#未完成为1 标志位

    # 调用start自动执行的函数

    def run(self):

    self.result = self.func()

    self.result = 0#完成返回0

    这样就可以判断os.sysytem里语句是否执行完成是否

    补充知识:python的threading.Thread线程的start、run、join、setDaemon

    Pycharm整体看下Thread类的内容:模拟的是Java的线程模型

    表示方法method,上面的锁头表示这个是类内部的方法,从方法名字命名规范可以看出,都是_和__开头的,一个下划线表示是子类可以继承,两个下划线表示是只有Thread内部可以访问,子类都不可以访问。

    表示property,可以使用类直接访问:Thread._block

    表示field,就是self.x定义的东东

    表示变量variable

    name/getName/setName是线程名字有关的;

    isDaemon是否是守护进程

    setDaemon设置为守护进程,如果把调用线程设置为守护线程,那么等调用线程结束后,被调用的子线程结束与否都会随着守护线程结束

    isAlive线程是否是活动状态

    start方法开启一个新线程。把需要并行处理的代码放在run()方法中,start()方法启动线程将自动调用 run()方法。

    run线程实际在运行的内容,可以被子类继承和重写overide。

    join阻塞调用它的线程,直到等待被调用的线程运行结束,其实就变成了单线程。参数timeout的作用是,当前线程等待被调用的子线程的时间,如果时间到了,不管子线程是否结束,当前线程都进入就绪状态,重新等待CPU调度。

    Join方法的Java示例:

    新建一个Thread类,重写run()方法:

    public class MyThread extends Thread {

    @Override

    public void run() {

    System.out.println("子线程执行完毕");

    }

    }

    新建测试类,测试Join()方法:

    public class TestThread {

    public static void main(String[] args) {

    //循环五次

    for (int i = 0; i < 5; i++) {

    MyThread thread = new MyThread();

    //启动线程

    thread.start();

    try {

    //调用join()方法

    thread.join();

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    System.out.println("主线程执行完毕");

    System.out.println("~~~~~~~~~~~~~~~");

    }

    }

    }

    输出结果如下:

    子线程执行完毕

    主线程执行完毕

    ~~~~~~~~~~~~~~~

    子线程执行完毕

    主线程执行完毕

    ~~~~~~~~~~~~~~~

    子线程执行完毕

    主线程执行完毕

    ~~~~~~~~~~~~~~~

    子线程执行完毕

    主线程执行完毕

    ~~~~~~~~~~~~~~~

    子线程执行完毕

    主线程执行完毕

    ~~~~~~~~~~~~~~~

    结果分析: 子线程每次都在主线程之前执行完毕,即子线程会在主线程之前执行。

    什么时候用join()方法?

    在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其他的事务后,需要用到子线程的处理结果,也就是主线程需要等待子线程执行完成之后再结束,这个时候就要用到join()方法了。

    用start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到cpu时间片,就开始执行run()方法,这里方法 run()称为线程体,它包含了要执行的这个线程的内容,run方法运行结束,此线程随即终止。

    run()方法只是类的一个普通方法而已,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条,还是要顺序执行,还是要等待run方法体执行完毕后才可继续执行下面的代码,这样就没有达到写线程的目的。

    总结:调用start方法方可启动线程,而run方法只是thread的一个普通方法调用,还是在主线程里执行。把需要并行处理的代码放在run()方法中,start()方法启动线程将自动调用 run()方法

    可见join和setDaemon作用是相反的,一个是等待子线程结束,一个是不等到子线程结束,有可能把子线程强制结束。如果两个都不设置的时候,那么主线程和子线程各自运行各自的,互不干扰,谁结束都不会影响另一个运行情况:见https://www.jb51.net/article/185872.htm示例

    以上这篇判断Threading.start新线程是否执行完毕的实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持云海天教程。

    展开全文
  • ``` Thread t2 = new Thread(new ThreadStart(Scz)); Thread t = new Thread(new ThreadStart(update)); t2.Start(); t.Start(); ``` 先执行完t2 再去执行t 怎么搞
  • Thread thread = new Thread(SendOtherData); thread.Start();
  • java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的功能是往一个文件异步地写入内容,...

    在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的功能是往一个文件异步地写入内容,我需要在所有的子线程写入完毕后在文件末尾写“---END---”及关闭文件流等,这个时候我就需要某个标志位可以告诉我是否线程池中所有的子线程都已经执行完毕,我使用这种方式来判断。

    public classMySemaphore {

    public static void main(String[] args) throwsIOException, InterruptedException {

    final File stream = new File("c:\\temp\\stonefeng\\stream.txt");

    final OutputStream os = newFileOutputStream(stream);

    final OutputStreamWriter writer = newOutputStreamWriter(os);

    final Semaphore semaphore = new Semaphore(10);

    ExecutorService exec =Executors.newCachedThreadPool();

    final long start =System.currentTimeMillis();

    for (int i = 0; i < 10000000; i++) {

    final int num =i;

    Runnable task = newRunnable() {

    @Override

    public voidrun() {

    try{

    semaphore.acquire();

    writer.write(String.valueOf(num)+"\n");

    semaphore.release();

    } catch(IOException e) {

    e.printStackTrace();

    } catch(InterruptedException e) {

    e.printStackTrace();

    }

    }

    };

    exec.submit(task);

    }

    exec.shutdown();while(true){

    if(exec.isTerminated()){

    writer.write("---END---\n");

    writer.close();

    System.out.println("所有的子线程都结束了!");

    break;

    }

    Thread.sleep(1000);

    }final long end =System.currentTimeMillis();

    System.out.println((end-start)/1000);

    }

    }

    当调用ExecutorService.shutdown方法的时候,线程池不再接收任何新任务,但此时线程池并不会立刻退出,直到添加到线程池中的任务都已经处理完成,才会退出。在调用shutdown方法后我们可以在一个死循环里面用isTerminated方法判断是否线程池中的所有线程已经执行完毕,如果子线程都结束了,我们就可以做关闭流等后续操作了。

    判断线程池中的线程是否全部执行完毕的另外一种解决方案则是使用闭锁(CountDownLatch)来实现,CountDownLatch是一种灵活的闭锁实现,它可以使一个或多个线程等待一组事件发生。闭锁状态包括一个计数器,该计数器被初始化为一个正数,表示需要等待的事件数量。countDown方法递减计数器,表示有一个事件已经发生了,而await方法等待计数器达到零,即表示需要等待的事情都已经发生。可以使用闭锁来这样设计程序达到目的:

    1 public classCountDownLatchApproach {

    2 public static void main(String[] args) throwsIOException, InterruptedException {

    3 final int nThreads = 10;

    4 final CountDownLatch endGate = new CountDownLatch(nThreads);5 final File stream = new File("c:\\temp\\stonefeng\\stream.txt");

    6 final OutputStream os = newFileOutputStream(stream);

    7 final OutputStreamWriter writer = newOutputStreamWriter(os);

    8 ExecutorService exec =Executors.newCachedThreadPool();

    9 for (int i = 0; i < nThreads; i++) {

    10 final int num =i;

    11 Runnable task = newRunnable() {

    12 @Override

    13 public voidrun() {

    14 try{

    15 writer.write(String.valueOf(num)+"\n");

    16 } catch(IOException e) {

    17 e.printStackTrace();

    18 } finally{

    19 endGate.countDown();20 }

    21 }

    22 };

    23 exec.submit(task);

    24 }

    25 endGate.await();26 writer.write("---END---\n");

    27 writer.close();

    28 }

    29 }

    这种解决方案虽然可以达到目的但是性能差到没朋友,我更倾向于使用第一种方案。

    现在我们有了更优雅的第三种方案,它的执行性能也不错。

    1 public classMySemaphore {

    2

    3 public static void main(String[] args) throwsIOException, InterruptedException {

    4 final File stream = new File("c:\\temp\\stonefeng\\stream.txt");

    5 final OutputStream os = newFileOutputStream(stream);

    6 final OutputStreamWriter writer = newOutputStreamWriter(os);

    7 final Semaphore semaphore = new Semaphore(10);

    8 ExecutorService exec =Executors.newCachedThreadPool();

    9

    10 final long start =System.currentTimeMillis();

    11 for (int i = 0; i < 10000000; i++) {

    12 final int num =i;

    13 Runnable task = newRunnable() {

    14 @Override

    15 public voidrun() {

    16 try{

    17 semaphore.acquire();

    18 writer.write(String.valueOf(num)+"\n");

    19 semaphore.release();

    20 } catch(IOException e) {

    21 e.printStackTrace();

    22 } catch(InterruptedException e) {

    23 e.printStackTrace();

    24 }

    25 }

    26 };

    27 exec.submit(task);

    28 }

    29 exec.shutdown();

    30 exec.awaitTermination(1, TimeUnit.HOURS);31 writer.write("---END---\n");

    32 writer.close();

    33 System.out.println("ËùÓеÄ×ÓÏ̶߳¼½áÊøÁË£¡");

    34 final long end =System.currentTimeMillis();

    35 System.out.println((end-start)/1000);

    36 }

    37 }

    展开全文
  • } } 2.CountDownLatch类 一个同步辅助类,常用于某个条件发生后才能执行后续进程。给定计数初始化CountDownLatch,调用countDown()方法,在计数到达零之前,await方法一直受阻塞。 重要方法为countdown()与await...

    该问题大概有3种方法:

    1.notify、wait方法,Java中的唤醒与等待方法,关键为synchronized代码块,也常用Object作为参数,示例如下。

     

    package com.thread_lc;
    
    class MyThread1 implements Runnable
    {
        public int i = 10;
     
        @Override
        public void run ()
        {
            Thread currThread = Thread.currentThread ();
            synchronized (currThread)
            {
                ++i;
                System.out.println (this.getClass ().getName () + " i = " + i);
                currThread.notify ();
            }
        }
    }
    

     

    package com.thread_lc;
    
    class MyThread2 implements Runnable
    {
        @Override
        public void run ()
        {
            Thread currThread = Thread.currentThread ();
            synchronized (currThread)
            {
                while ("t1".equals (currThread.getName ()))
                {
                    try
                    {
                        currThread.wait (0);
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace ();
                    }
                }
                done ();
            }
        }
     
        public synchronized void done ()
        {
            System.out.println ("更改完毕");
        }
    }
    

     

    package com.thread_lc;
    
    public class MyThreadMain {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		MyThread1 myThread1 = new MyThread1();
    		MyThread2 myThread2 = new MyThread2();
    		Thread t1 = new Thread(myThread1);
    		t1.setName("t1");
    		t1.start();
    		Thread t2 = new Thread(myThread2);
    		t2.setName("t2");
    		t2.start();
    	}
    
    }
    

     

    2.CountDownLatch类

    一个同步辅助类,常用于某个条件发生后才能执行后续进程。给定计数初始化CountDownLatch,调用countDown()方法,在计数到达零之前,await方法一直受阻塞。

    重要方法为countdown()与await();

    示例如下。

     

    package com.thread_lc;
    
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Test4 {
    
    	class DTask implements Runnable {
    		private CountDownLatch downLatch;
    
    		private String name;
    
    		public DTask(CountDownLatch downLatch, String name) {
    			this.downLatch = downLatch;
    			this.name = name;
    		}
    		
    		@Override
    		public void run() {
    			if (name.equals("A"))
    				try {
    					this.downLatch.await();
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			for (int i = 0; i < 20; i++) {
    				System.out.println(Thread.currentThread().getName() + "====>" + i);
    			}
    
    			// if(name.equals("B"))
    			this.downLatch.countDown();
    		}
    
    	}
    
    	public static void test1() {
    		ExecutorService service = Executors.newFixedThreadPool(2);
    		Test4 tt = new Test4();
    		CountDownLatch downLatch = new CountDownLatch(1);
    		service.execute(tt.new DTask(downLatch, "A"));
    		service.execute(tt.new DTask(downLatch, "B"));
    		service.shutdown();
    
    	}
    
    	public static void main(String[] args) {
    		test1();
    
    	}
    
    }
    

     

    3.join方法

    将线程B加入到线程A的尾部,当A执行完后B才执行。示例如下。

     

    package com.thread_lc;
    
    public class Th extends Thread {
    	private final String name;
    
    	public Th(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void run() {
    		super.run();
    		for (int i = 0; i < 100; i++)
    			System.err.println(name + "\t" + i);
    	}
    
    	public static void main(String[] args) throws Exception {
    		Th t = new Th("t1");
    		Th t2 = new Th("t2");
    		t.start();
    		t.join();
    		t2.start();
    	}
    }
    

     

     

     

     

     

    展开全文
  • 一个线程如果执行完它的run(),那就意味着该线程结束了,并且无法再次调用run(),等待系统回收。 那么如果下次还想调用run()怎么办? 答:可以新建该线程或者使用线程池(避免回收线程和创建线程的开销) ...
  • 现在有一个主线程X,和两个子线程A和B,A和B之间没有依赖关系且两者的执行时间不确定,现在要求如下: 1:不限制A和B执行顺序的 2:主线程X需要在子线程A和B执行完成之后再执行 方案1 1)思路 使用join()方法实现 2...
  • 题目要求:创建三个线程,每个线程分别打印ABC,并按照ABC的顺序执行十次 题目可以使用多种不同的方式解决,下面我们分别使用 Condition 等待唤醒机制、Semaphore 信号量、CountDownLatch 闭锁、Thread.join() 方法...
  • final Lock lc = new ReentrantLock(); .. run() { lc.lock();...改用join() 可以实现(BC与A以单线程模式执行),代码如下: package com.w.thread; import java.util.concurrent.locks.Lock; import ...
  • 这里记录一下下面这种情况:主线程需要等待多个子线程执行完后再执行。...示例如下,我们初始化一个CountDownLatch,值为10(子线程个数),然后每次一个子线程执行完执行一下countDown(),代码示例如下:...
  • 在多线程环境下,我们可能会需要等待开辟的线程执行完后,再去执行某个方法,例如输出并行计算结果等。 但是在多线程下,线程的执行是不阻塞主线程的,这点其实也是多线程的优势,提高代码执行效率,不必相互等待...
  • 问题最近我在处理批数据,用多线程来处理,我想知道大概多久能处理。比如我先用多线程处理 100 条数据,统计下用时,然后根据总的数据量就可以大概估算出处理这批数据要多久。使用 CountDownLatch 计时思路:...
  • 如何确保三个线程顺序执行

    万次阅读 多人点赞 2018-07-03 09:42:00
    确保三个线程t1执行完后t2执行,t2执行完成后t3执行。1.使用join1.使用join thread.Join把指定的线程加入到当前线程,可以将两交替执行线程合并为顺序执行线程。比如在线程B中调用了线程A的Join()方法,直到...
  • java多线程如何让一个线程执行一次?我目前只能是检测到getname()然后用wait()方法。想知道还有没其他方法? ``` public class TicketSale { public static void main(String[] args) { ...
  • 线程1执行(cond),线程1执行一半等待(cond.wait()),线程2开始执行(cond),线程2执行完毕后(cond.notify()),线程1再接着执行。 import threading import time def go1(): with cond: #使用条件变量...
  • 如何获取多线程执行结果-java

    万次阅读 2021-08-12 16:08:05
    我们知道join方法的目的是让一个线程等待另一个线程结束后才能执行,利用此原理我们可以设置一个监控线程用来等待程序线程执行完毕后输出返回结果,下面我们下具体示例代码 首先定义一个结果实体类 public ...
  • 在python程序中,我们往往会遇到需要在一个脚本里面,同时执行多项任务的需求,那么此时,我们可以开启一个线程执行。 如下面,我需要开启一个读取redis白名单线程任务。 每一分钟跟新一次用户白名单。 import ...
  • Java主线程等待所有子线程执行完毕在执行,这个需求其实我们在工作中经常会用到,比如用户下单一个产品,后台会做一系列的处理,为了提高效率,每个处理都可以用一个线程执行,所有处理完成了之后才会返回给用户...
  • 面试题:如何让线程顺序执行

    万次阅读 2019-09-22 10:23:52
    、实现 本文使用了8种方法实现在多线程中让线程按顺序运行的方法,涉及到多线程中许多常用的方法,不止为了知道如何让线程按顺序运行,更是让读者对多线程的使用有更深刻的了解。使用的方法如下: [1] 使用线程的...
  • 判断多线程是否全部执行完毕

    千次阅读 2017-02-13 20:30:59
    java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的功能是往一个文件异步地写入内容,...
  • 1.根据线程池中的总线程数目等于完成的线程数目package com.luna.thread; import java.util.Random; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import ...
  • Thread tr = null; delegate void Methinvoker(); private void btSeInfo_Click(object sender, EventArgs e) { tr = new Thread(new ThreadStart(SeleInfo)); tr
  • 、准备工作 在Application类上加上EnableAsync注解开启异步 在被调用的方法上面加上@Async,也可以直接在类上加此注解,会标识所有方法为异步方法 注意事项 必须要加@EnableAsync注解 不能在同类下调...
  • 实现两个线程交替执行

    千次阅读 2019-06-04 09:26:24
    题目:使用多线程实现输出的效果为: 1 -1 2 -2 3 -3 4 -4 … package com.thread.synchronizedDemo.lock; import java.util.concurrent.locks.ReentrantLock; /** * @author 007 * @ClassName 类名称 * @...
  • 博主昨天去一家公司面试,被面试官问到一个问题,如果开启10个线程,但是需要这10个线程执行完成后,再交由主线程统一输入,如何实现?当时我没有回答,我对多线程并不是那么的熟悉,面试结束后,我通过查阅资料...
  • java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的功能是往一个文件异步地写入内容,...
  • java多线程执行任务(工具)

    千次阅读 2022-03-09 14:54:09
    在项目开发的过程中经常会碰到多线程执行任务,每次用线程池实现时,由于每次的需求都有所差别有时是所有任务同时执行有时是分批次执行有时还需要知道所有任务什么时候执行...今天闲着写了一个通用的多线程执行工具。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,981,908
精华内容 792,763
关键字:

如何看一个线程是否执行完