- 浏览: 180229 次
- 性别:
- 来自: 上海
最新评论
-
dongdong12345_:
感谢楼主,帮到了我
根据当前日期算前一年、前一月、前一天(java基础) -
kyson:
lz活生生地弄了一个线程池啊。。
Java多线程--让主线程等待所有子线程执行完毕 -
liyong635:
楼主太给力了~赞一个~~
eclipse birt使用脚本实现换行 -
xining:
其实可以使用 ThreadGroup 调用ThreadG ...
Java多线程--让主线程等待所有子线程执行完毕 -
guowusmiile:
何必这么麻烦,其实只需要一个for循环,就可以解决LZ标题问题 ...
Java多线程--让主线程等待所有子线程执行完毕
朋友让我帮忙写个程序从文本文档中导入数据到oracle数据库中,技术上没有什么难度,文档的格式都是固定的只要对应数据库中的字段解析就行了,关键在于性能。
数据量很大百万条记录,因此考虑到要用多线程并发执行,在写的过程中又遇到问题,我想统计所有子进程执行完毕总共的耗时,在第一个子进程创建前记录当前时间用System.currentTimeMillis()在最后一个子进程结束后记录当前时间,两次一减得到的时间差即为总共的用时,代码如下
结果是几乎在for循环结束的瞬间就执行了主线程打印总共用时的语句,原因是所有的子线程是并发执行的,它们运行时主线程也在运行,这就引出了一个问题即本文标题如何"让主线程等待所有子线程执行完毕"。试过在每个子线程开始后加上t.join(),结果是所有线程都顺序执行,这就失去了并发的意义了,显然不是我想要的。
网上Google了很久也没有找到解决方案,难道就没有人遇到过这种需求吗?还是这个问题太简单了?无耐只得自己想办法了...
最后我的解决办法是,自定义一个ImportThread类继承自java.lang.Thread,重载run()方法,用一个List属性保存所有产生的线程,这样只要判断这个List是否为空就知道还有没有子线程没有执行完了,类代码如下:
主线程中代码:
打印的结果是:
main开始
Thread-1开始...
Thread-5开始...
Thread-0开始...
Thread-2开始...
Thread-3开始...
Thread-4开始...
Thread-5结束.
Thread-4结束.
Thread-2结束.
Thread-0结束.
Thread-3结束.
Thread-1结束.
main结束.
总共用时:20860millions
可以看到main线程是等所有子线程全部执行完后才开始执行的。
==================================================以下为第二次编辑===============================================
上面的方法有一个隐患:如果线程1开始并且结束了,而其他线程还没有开始此时runningThreads的size也为0,主线程会以为所有线程都执行完了。解决办法是用一个非简单类型的计数器来取代List型的runningThreads,并且在线程创建之前就应该设定好计数器的值。
MyCountDown类
ImportThread类
主线程中
打印结果:
main开始
Thread-2开始...
Thread-1开始...
Thread-0开始...
Thread-3开始...
Thread-5开始...
Thread-4开始...
Thread-5结束. 还有5 个线程
Thread-1结束. 还有4 个线程
Thread-4结束. 还有3 个线程
Thread-2结束. 还有2 个线程
Thread-3结束. 还有1 个线程
Thread-0结束. 还有0 个线程
main结束.
更简单的方法:使用java.util.concurrent.CountDownLatch代替MyCountDown,用await()方法代替while(true){...}
ImportThread类
主线程中
打印结果:
main开始
Thread-1开始...
Thread-0开始...
Thread-2开始...
Thread-3开始...
Thread-4开始...
Thread-5开始...
Thread-0结束. 还有5 个线程
Thread-1结束. 还有4 个线程
Thread-4结束. 还有3 个线程
Thread-2结束. 还有2 个线程
Thread-5结束. 还有1 个线程
Thread-3结束. 还有0 个线程
main结束.
貌似用join之后,线程之间就变成串行的了,不是并行的了。这样会严重影响效率。
假设有100万条记录,顺序执行的话光是遍历完这100万条记录就要很长时间了,现在开10个线程,每个线程只要插入10万条,是不是会快很多?
看你几块disk,只有一块的话单线顺序程读写就是最快了 磁盘是sequantial access才快的 多线程access pattern被打乱了会慢因为这相当于random access了
我前面说了因为有xmltype类型的字段,所以想用java先解析一下再插入
因为表中有个字段是xmltype型的,插入时需调用oracle的sys.xmltype.createXml()来创建xmltype对象然后插入,这样服务器端压力会很大,所以想用java在客户端创建好XMLType对象,这样服务器端就少了创建xmltype对象的压力了
数据量很大百万条记录,因此考虑到要用多线程并发执行,在写的过程中又遇到问题,我想统计所有子进程执行完毕总共的耗时,在第一个子进程创建前记录当前时间用System.currentTimeMillis()在最后一个子进程结束后记录当前时间,两次一减得到的时间差即为总共的用时,代码如下
long tStart = System.currentTimeMillis(); System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记 for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程 Runnable r = new Runnable(){ @Override public void run(){ System.out.println(Thread.currentThread().getName() + "开始"); //做一些事情... ... System.out.println(Thread.currentThread().getName() + "结束."); } } Thread t = new Thread(r); t.start(); } System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记 long tEnd = System.currentTimeMillis(); System.out.println("总共用时:"+ (tEnd - tStart) + "millions");
结果是几乎在for循环结束的瞬间就执行了主线程打印总共用时的语句,原因是所有的子线程是并发执行的,它们运行时主线程也在运行,这就引出了一个问题即本文标题如何"让主线程等待所有子线程执行完毕"。试过在每个子线程开始后加上t.join(),结果是所有线程都顺序执行,这就失去了并发的意义了,显然不是我想要的。
网上Google了很久也没有找到解决方案,难道就没有人遇到过这种需求吗?还是这个问题太简单了?无耐只得自己想办法了...
最后我的解决办法是,自定义一个ImportThread类继承自java.lang.Thread,重载run()方法,用一个List属性保存所有产生的线程,这样只要判断这个List是否为空就知道还有没有子线程没有执行完了,类代码如下:
public class ImportThread extends Thread { private static List<Thread> runningThreads = new ArrayList<Thread>(); public ImportThread() { } @Override public void run() { regist(this);//线程开始时注册 System.out.println(Thread.currentThread().getName() + "开始...");//打印开始标记 //做一些事情... ... unRegist(this);//线程结束时取消注册 System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记 } public void regist(Thread t){ synchronized(runningThreads){ runningThreads.add(t); } } public void unRegist(Thread t){ synchronized(runningThreads){ runningThreads.remove(t); } } public static boolean hasThreadRunning() { return (runningThreads.size() > 0);//通过判断runningThreads是否为空就能知道是否还有线程未执行完 } }
主线程中代码:
long tStart = System.currentTimeMillis(); System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记 for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程 Thread t = new ImportThread(); t.start(); } while(true){//等待所有子线程执行完 if(!ImportThread.hasThreadRunning()){ break; } Thread.sleep(500); } System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记 long tEnd = System.currentTimeMillis(); System.out.println("总共用时:"+ (tEnd - tStart) + "millions");
打印的结果是:
main开始
Thread-1开始...
Thread-5开始...
Thread-0开始...
Thread-2开始...
Thread-3开始...
Thread-4开始...
Thread-5结束.
Thread-4结束.
Thread-2结束.
Thread-0结束.
Thread-3结束.
Thread-1结束.
main结束.
总共用时:20860millions
可以看到main线程是等所有子线程全部执行完后才开始执行的。
==================================================以下为第二次编辑===============================================
上面的方法有一个隐患:如果线程1开始并且结束了,而其他线程还没有开始此时runningThreads的size也为0,主线程会以为所有线程都执行完了。解决办法是用一个非简单类型的计数器来取代List型的runningThreads,并且在线程创建之前就应该设定好计数器的值。
MyCountDown类
public class MyCountDown { private int count; public MyCountDown(int count){ this.count = count; } public synchronized void countDown(){ count--; } public synchronized boolean hasNext(){ return (count > 0); } public int getCount() { return count; } public void setCount(int count) { this.count = count; } }
ImportThread类
public class ImportThread extends Thread { private MyCountDown c; public ImportThread(MyCountDown c) { this.c = c; } @Override public void run() { System.out.println(Thread.currentThread().getName() + "开始...");//打印开始标记 //Do something c.countDown();//计时器减1 System.out.println(Thread.currentThread().getName() + "结束. 还有" + c.getCount() + " 个线程");//打印结束标记 } }
主线程中
System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记 MyCountDown c = new MyCountDown(threadNum);//初始化countDown for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程 Thread t = new ImportThread(c); t.start(); } while(true){//等待所有子线程执行完 if(!c.hasNext()) break; } System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
打印结果:
main开始
Thread-2开始...
Thread-1开始...
Thread-0开始...
Thread-3开始...
Thread-5开始...
Thread-4开始...
Thread-5结束. 还有5 个线程
Thread-1结束. 还有4 个线程
Thread-4结束. 还有3 个线程
Thread-2结束. 还有2 个线程
Thread-3结束. 还有1 个线程
Thread-0结束. 还有0 个线程
main结束.
更简单的方法:使用java.util.concurrent.CountDownLatch代替MyCountDown,用await()方法代替while(true){...}
ImportThread类
public class ImportThread extends Thread { private CountDownLatch threadsSignal; public ImportThread(CountDownLatch threadsSignal) { this.threadsSignal = threadsSignal; } @Override public void run() { System.out.println(Thread.currentThread().getName() + "开始..."); //Do somethings threadsSignal.countDown();//线程结束时计数器减1 System.out.println(Thread.currentThread().getName() + "结束. 还有" + threadsSignal.getCount() + " 个线程"); } }
主线程中
CountDownLatch threadSignal = new CountDownLatch(threadNum);//初始化countDown for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程 final Iterator<String> itt = it.get(ii); Thread t = new ImportThread(itt,sql,threadSignal); t.start(); } threadSignal.await();//等待所有子线程执行完 System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
打印结果:
main开始
Thread-1开始...
Thread-0开始...
Thread-2开始...
Thread-3开始...
Thread-4开始...
Thread-5开始...
Thread-0结束. 还有5 个线程
Thread-1结束. 还有4 个线程
Thread-4结束. 还有3 个线程
Thread-2结束. 还有2 个线程
Thread-5结束. 还有1 个线程
Thread-3结束. 还有0 个线程
main结束.
评论
72 楼
kyson
2014-01-17
lz活生生地弄了一个线程池啊。。
71 楼
xining
2013-07-03
其实可以使用 ThreadGroup 调用ThreadGroup的activeCount方法 ==0 就是子线程全部结束, 主线程可以继续往下走
70 楼
guowusmiile
2013-05-13
何必这么麻烦,其实只需要一个for循环,就可以解决LZ标题问题
List<Thread> tList = new ArrayList<Thread>();
for (int i = 0; i < tList.size(); i++) {
try {
tList.get(i).join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
只要在子线程结束的时候增加这些代码即可,谢谢!
List<Thread> tList = new ArrayList<Thread>();
for (int i = 0; i < tList.size(); i++) {
try {
tList.get(i).join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
只要在子线程结束的时候增加这些代码即可,谢谢!
69 楼
tonghaoqi__
2013-05-10
楼主写的挺好的 也挺清晰的 我不明白别人为啥看不明白,什么样的才算是明白呢? 唉不说那些了。
感觉能做下试验验证一下,呵呵 收走了,,
感觉能做下试验验证一下,呵呵 收走了,,
68 楼
avi9111
2012-06-19
好像用
join就能做到了
t.join()
写了几年c#的线程,很多东西都很简单就做到了,可以说我连概念都没搞清楚就能用了,所见即所得,想到就能做到
不知道为什么现在用java的线程那么难用
不知道为什么现在看用java线程的程序员的文章都复杂的要命
join就能做到了
t.join()
写了几年c#的线程,很多东西都很简单就做到了,可以说我连概念都没搞清楚就能用了,所见即所得,想到就能做到
不知道为什么现在用java的线程那么难用
不知道为什么现在看用java线程的程序员的文章都复杂的要命
67 楼
foart
2012-06-16
看上去使用java.util.concurrent.CountDownLatch,最后一个办法挺简单清晰的,有空试试看。
66 楼
yunnysunny
2011-09-21
yiyidog125 写道
干吗不用join?没理解错的话就是主线程等着子线程们结束吧
yiyidog125 写道
干吗不用join?没理解错的话就是主线程等着子线程们结束吧
貌似用join之后,线程之间就变成串行的了,不是并行的了。这样会严重影响效率。
65 楼
yiyidog125
2010-10-29
yadsun 写道
nishizhutoua 写道
说句老实话,你确定你的这个需求要用多线程么?
读的方面,瓶颈在IO,用单线程,全速的读就是最快的了.除非你在读取一行数据后要对行数据进行格式化,并且这个格式化时间消耗要大于理论上的连续读两行文本时的CPU时间. 不过恐怕不容易吧,这两个时间差好几个级.
写的部分,瓶颈还是在IO,因为你要写到数据库中.
这么算两个线程就够了,生产者消费者模式即可.
读的方面,瓶颈在IO,用单线程,全速的读就是最快的了.除非你在读取一行数据后要对行数据进行格式化,并且这个格式化时间消耗要大于理论上的连续读两行文本时的CPU时间. 不过恐怕不容易吧,这两个时间差好几个级.
写的部分,瓶颈还是在IO,因为你要写到数据库中.
这么算两个线程就够了,生产者消费者模式即可.
假设有100万条记录,顺序执行的话光是遍历完这100万条记录就要很长时间了,现在开10个线程,每个线程只要插入10万条,是不是会快很多?
看你几块disk,只有一块的话单线顺序程读写就是最快了 磁盘是sequantial access才快的 多线程access pattern被打乱了会慢因为这相当于random access了
64 楼
yiyidog125
2010-10-29
干吗不用join?没理解错的话就是主线程等着子线程们结束吧
63 楼
yadsun
2010-10-29
cjmcn-sh 写道
import java.util.concurrent.*
然后做该做的事情
oracle导数据还要写程序?
然后做该做的事情
oracle导数据还要写程序?
我前面说了因为有xmltype类型的字段,所以想用java先解析一下再插入
62 楼
cjmcn-sh
2010-10-28
import java.util.concurrent.*
然后做该做的事情
oracle导数据还要写程序?
然后做该做的事情
oracle导数据还要写程序?
61 楼
luobin23628
2010-10-27
循环栅栏比计数器跟适合楼主的这个应用场景
public static void main(String[] args) throws InterruptedException { int threadNumber = 10; final long start = System.currentTimeMillis(); CyclicBarrier barrier = new CyclicBarrier(threadNumber,new Runnable(){ @Override public void run() { long end = System.currentTimeMillis(); System.out.println("total time : "+(end-start)+"ms"); } }); for (int i = 0; i < threadNumber; i++) { new ImportThread(barrier,i).start(); } System.out.println("main thread finished!!"); } private static class ImportThread extends Thread{ private final CyclicBarrier barrier; private final int threadID; public ImportThread(CyclicBarrier barrier,int threadID){ this.barrier = barrier; this.threadID = threadID; } public void run() { try { Thread.sleep((long) (Math.random() * 10000)); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(String.format("threadID:[%s] finished!!", threadID)); try { barrier.await(); } catch (InterruptedException e1) { e1.printStackTrace(); } catch (BrokenBarrierException e1) { e1.printStackTrace(); } } }
60 楼
babecue
2010-10-27
把所有子线程启动了之后再逐一调用join()不行吗?
59 楼
thorlst
2010-02-01
ReadWriteLock rwl = new ReentrantReadWriteLock(); //执行子线程 for(....){ rwl.readLock().lock(); new Thread(new Runnable(){ public void run(){ try{ ... }finally{ rwl.readLock().unlock(); } } }).start(); } //等待子线程 try { rwl.writeLock().lock(); } finally { rwl.writeLock().unlock(); }
58 楼
yadsun
2010-01-31
蓝皮鼠 写道
这个主题,如果是导入数据到Oracle,用SQL Loader最简单最快,如果在借题发挥到并发多任务,就是一个很大的话题了。
好像这篇帖子的内容相关
http://www.iteye.com/topic/405492
好像这篇帖子的内容相关
http://www.iteye.com/topic/405492
fuermos 写道
大数据量,用oralce sqlLoad就行了,都不需要java
因为表中有个字段是xmltype型的,插入时需调用oracle的sys.xmltype.createXml()来创建xmltype对象然后插入,这样服务器端压力会很大,所以想用java在客户端创建好XMLType对象,这样服务器端就少了创建xmltype对象的压力了
57 楼
zcq100
2010-01-30
在main里面循环判断线程池里面线程是否运行完毕即可
56 楼
lyy3323
2010-01-29
楼主你的问题其实很简单。。。
countdown 就行了。。。
如果你确定了你开启的线程数。
那么在主程序运行前。
CountDownLatch countdown = new CountDownLatch(10);//这里的10就是你的子线程数。
在每个子线程结束后,调用 countdown.countDown();
在主线程里启动子线程的方法后面添加。
countdown.await();//这里进行同步等待
等所有子线程结束后,执行 countdown.await()后面的代码
countdown 就行了。。。
如果你确定了你开启的线程数。
那么在主程序运行前。
CountDownLatch countdown = new CountDownLatch(10);//这里的10就是你的子线程数。
在每个子线程结束后,调用 countdown.countDown();
在主线程里启动子线程的方法后面添加。
countdown.await();//这里进行同步等待
等所有子线程结束后,执行 countdown.await()后面的代码
55 楼
fuermos
2010-01-29
大数据量,用oralce sqlLoad就行了,都不需要java
54 楼
蓝皮鼠
2010-01-29
这个主题,如果是导入数据到Oracle,用SQL Loader最简单最快,如果在借题发挥到并发多任务,就是一个很大的话题了。
好像这篇帖子的内容相关
http://www.iteye.com/topic/405492
好像这篇帖子的内容相关
http://www.iteye.com/topic/405492
53 楼
xuyan2680
2010-01-29
多线程---批量线程同步模型
在一批线程处理程序中,有时必须等到所有线程全部运行完后,才能进行下一步任务处理,
可以采用如下方法解决,创建一个锁对象 ,该锁对象提供一个当前线程等待其他线程的方法。见代码:
此对象提供 二个私有变量,totalThread 的初始值为所运行的线程的总数,currentThread 为当前正在运行的线程数。
此对象提供 二个私有变量,totalThread 的初始值为所运行的线程的总数,currentThread 为当前正在运行的线程数。Java代码
线程运行时处理完自己的任务后调用方法waitForOtherThread 等待其他线程结束,即当前运行线程数与线程总数的比较
线程运行时处理完自己的任务后调用方法waitForOtherThread 等待其他线程结束,即当前运行线程数与线程总数的比较Java代码
如果运行线程数小于线程总数,则当前运行线程数+1 后,当前线程进入等待状态,否则,唤醒其他等待线程。
如果运行线程数小于线程总数,则当前运行线程数+1 后,当前线程进入等待状态,否则,唤醒其他等待线程。
见测试程序
http://xuyan2680.iteye.com/admin/blogs/467701
在一批线程处理程序中,有时必须等到所有线程全部运行完后,才能进行下一步任务处理,
可以采用如下方法解决,创建一个锁对象 ,该锁对象提供一个当前线程等待其他线程的方法。见代码:
/** * * 此类主要用来处理线程的同步屏蔽模型,比如,一批线程运行,必须在最后一个线程运行 * 完后,才能进行下一步的操作,那么就可以创建一个锁对象,锁对象提供一个线程等待其他线程 * 的方法,如果当前线程运行时,还有未运行的线程,则此线程wait,否则,此线程唤醒其他阻塞的 * 线程,进而最终完成线程的运行 * */ public class LockObject { private int totalThread = 0; private int currentThread = 0; public LockObject(int totalThread) { this.totalThread = totalThread; this.currentThread = 1; } public synchronized void waitForOtherThread() { if (this.currentThread < this.totalThread) { this.currentThread++; try { this.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } else { this.currentThread = 1; notifyAll(); } } public int getTotalThread() { return totalThread; } public void setTotalThread(int totalThread) { this.totalThread = totalThread; } public int getCurrentThread() { return currentThread; } public void setCurrentThread(int currentThread) { this.currentThread = currentThread; } } /** * * 此类主要用来处理线程的同步屏蔽模型,比如,一批线程运行,必须在最后一个线程运行 * 完后,才能进行下一步的操作,那么就可以创建一个锁对象,锁对象提供一个线程等待其他线程 * 的方法,如果当前线程运行时,还有未运行的线程,则此线程wait,否则,此线程唤醒其他阻塞的 * 线程,进而最终完成线程的运行 * */ public class LockObject { private int totalThread = 0; private int currentThread = 0; public LockObject(int totalThread) { this.totalThread = totalThread; this.currentThread = 1; } public synchronized void waitForOtherThread() { if (this.currentThread < this.totalThread) { this.currentThread++; try { this.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } else { this.currentThread = 1; notifyAll(); } } public int getTotalThread() { return totalThread; } public void setTotalThread(int totalThread) { this.totalThread = totalThread; } public int getCurrentThread() { return currentThread; } public void setCurrentThread(int currentThread) { this.currentThread = currentThread; } }
此对象提供 二个私有变量,totalThread 的初始值为所运行的线程的总数,currentThread 为当前正在运行的线程数。
此对象提供 二个私有变量,totalThread 的初始值为所运行的线程的总数,currentThread 为当前正在运行的线程数。Java代码
线程运行时处理完自己的任务后调用方法waitForOtherThread 等待其他线程结束,即当前运行线程数与线程总数的比较
线程运行时处理完自己的任务后调用方法waitForOtherThread 等待其他线程结束,即当前运行线程数与线程总数的比较Java代码
如果运行线程数小于线程总数,则当前运行线程数+1 后,当前线程进入等待状态,否则,唤醒其他等待线程。
如果运行线程数小于线程总数,则当前运行线程数+1 后,当前线程进入等待状态,否则,唤醒其他等待线程。
见测试程序
public class MyThread extends Thread { public static LockObject lo = new LockObject(1000); public MyThread(String threadName) { super(threadName); } public void run() { System.out.println(Thread.currentThread().getName() + " ----开始运行"); lo.waitForOtherThread(); System.out.println(Thread.currentThread().getName() + " ----结束运行"); } public static void main(String[] args) { for (int i = 1; i <= 1000; i++) { Thread thread = new MyThread("第" + i + "个线程"); thread.setPriority(NORM_PRIORITY); thread.start(); } } }
http://xuyan2680.iteye.com/admin/blogs/467701
发表评论
-
Jboss 5启动报IO异常的解决方法
2010-10-29 13:52 2965今天启动jboss报了个诡异的IO异常 错误代码: 引用 20 ... -
Ejb3持久化实体时的异常
2010-06-01 14:31 1330对某个Entity进行持久化操作时发生如下异常 Caused ... -
eclipse birt使用脚本实现换行
2010-02-02 13:20 4937使用Eclipse Birt有 ... -
java操作XMLType的几种方法
2010-02-02 13:16 5089XMLType是oracle数据库特有的数据类型可以 ... -
JavaEye怎么回事?s\cript竟成敏感词?
2010-02-02 13:14 1273今天本来准备写个帖子,结果不让提交 您的文章当中包含了敏感关键 ... -
未给Editor指定icon引发的异常
2010-01-18 16:27 1205扩展elcipse.ui.editor时报了org.ecl ... -
Eclipse Birt的列绑定错误
2010-01-15 16:52 1970今天用eclipse birt做报表时出现了一个错误困扰 ... -
根据当前日期算前一年、前一月、前一天(java基础)
2010-01-13 15:17 12680问题的本身没有什么难度,但是要想一下子找到一个现成的方法 ... -
Swt/Jface tableviewer 加入filter ,改变行的颜色
2009-12-15 11:18 2489原帖出处:http://blog.csdn.net/alex ... -
Eclipse Birt使用动态sql创建data set
2009-12-10 15:18 6264Eclipse Birt可以使用sql query来创 ... -
SSH框架中向数据库存取图片
2009-10-20 22:36 4555以前一直觉得向数据库中存图片是件挺麻烦的事情,今天自 ... -
Java中带复选框的树的级联选择与取消
2009-07-23 14:40 3745需要实现如下的功能: 当选中树中的某一节点时, ...
相关推荐
Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程执行完的五种方法 Java多线程--等待所有子线程...
Java主线程等待所有子线程执行完毕在执行,其实在我们的工作中经常的用到,本篇文章就介绍了Java多线程--让主线程等待所有子线程执行完毕在执行,有需要的可以了解一下。
数据量很大百万条记录,因此考虑到要用多线程并发执行,在写的过程中又遇到问题,我想统计所有子进程执行完毕总共的耗时,在第一个子进程创建前记录当前时间用System.currentTimeMillis()在后一个子进程结束后...
java 子线程通过观察者模式通知主线程
子线程更新主线程数据(再谈多线程)
Unity除了一些基本的数据类型,几乎所有的API都不能在子线程中调用,如果项目中有一段很耗时操作,unity可能会出现“卡死...因此针对这个问题再加上查找了一些资料,弄出了一个小工具,可以子线程与主线程的相互访问。
C# Winfrom必须掌握的技术,主线程显示数据,子线程获取数据,这是我做项目实际用到的技术。
非常实用不解释,用了才知道 个人收藏的一部分资料将陆续给大家上传
子线程任务发生异常,主线程事务如何回滚
我就废话不多说了,还是直接看代码吧! from time import ctime import threading import time def a(): #for i in range(5): print('Program a is running... at ', ctime(),u'.线程名为:',threading.current...
自己学着编写的一个JAVA多线程程序,该程序实现的功能是:在主线程main中创建两个子线程,A和B,线程A先运行,再运行B线程,当两个子线程都运行完毕后,才运行主线程,并最终结束整个程序的运行。 希望该程序对初学...
下面小编就为大家带来一篇C#子线程执行完后通知主线程的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
Handler消息传递详解,子线程到子线程,主线程到子线程,子线程到主线程 三种消息,Looper,Handler工作机制详解 https://blog.csdn.net/shoneworn/article/details/80447651
下面小编就为大家分享一篇Java父线程(或是主线程)等待所有子线程退出的实例,具有很好的参考价值,希望对大家有所帮助
C#子线程刷新主线程示例源码 功能介绍: 使用线程操作 1、实时显示当前时间 2、输入加数和被加数,自动出现结果 技术特点: 使用了多线程实现了子线程刷新主线程 ,使用委托刷新主线程。 注意: 开发环境为...
主线程如何捕获子线程的异常---马克-to-win java视频的介绍
c#子线程如何读取及设置主线程ui的值,自己录的一个小视频,方便理解,比较菜鸟的方法,请勿喷!
C++ thread退出线程 多线程 子线程控制退出主线程 window VS2017 Debug Error! Abort() has been called. C++ thread退出线程 多线程 子线程控制退出主线程 window VS2017 Debug Error! Abort() has been called.
AutoJs源码-子线程与主线程逻辑。本资源购买前提醒:本源码都是实际autojs项目模板,安装好autojs直接运行即可打开。1、支持低版本autojs。2、资源仅供学习与参考,请勿用于商业用途,否则产生的一切后果将由您自己...