`
yadsun
  • 浏览: 181365 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Java多线程--让主线程等待所有子线程执行完毕

多线程JavathreadOracle数据结构 
阅读更多
    朋友让我帮忙写个程序从文本文档中导入数据到oracle数据库中,技术上没有什么难度,文档的格式都是固定的只要对应数据库中的字段解析就行了,关键在于性能。
    数据量很大百万条记录,因此考虑到要用多线程并发执行,在写的过程中又遇到问题,我想统计所有子进程执行完毕总共的耗时,在第一个子进程创建前记录当前时间用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结束.
分享到：
| 未给Editor指定icon引发的异常
评论
52 楼 zli.ray 2010-01-29  
yadsun 写道
nishizhutoua 写道
说句老实话,你确定你的这个需求要用多线程么?
读的方面,瓶颈在IO,用单线程,全速的读就是最快的了.除非你在读取一行数据后要对行数据进行格式化,并且这个格式化时间消耗要大于理论上的连续读两行文本时的CPU时间. 不过恐怕不容易吧,这两个时间差好几个级.
写的部分,瓶颈还是在IO,因为你要写到数据库中.
这么算两个线程就够了,生产者消费者模式即可.

假设有100万条记录,顺序执行的话光是遍历完这100万条记录就要很长时间了,现在开10个线程,每个线程只要插入10万条,是不是会快很多?

这个不一定，可能更慢。
并不是说开多个线程，速度就一定会快的，线程切换也有开销。
51 楼 yadsun 2010-01-29  
nishizhutoua 写道
说句老实话,你确定你的这个需求要用多线程么?
读的方面,瓶颈在IO,用单线程,全速的读就是最快的了.除非你在读取一行数据后要对行数据进行格式化,并且这个格式化时间消耗要大于理论上的连续读两行文本时的CPU时间. 不过恐怕不容易吧,这两个时间差好几个级.
写的部分,瓶颈还是在IO,因为你要写到数据库中.
这么算两个线程就够了,生产者消费者模式即可.

假设有100万条记录,顺序执行的话光是遍历完这100万条记录就要很长时间了,现在开10个线程,每个线程只要插入10万条,是不是会快很多?
50 楼 nishizhutoua 2010-01-29  
说句老实话,你确定你的这个需求要用多线程么?
读的方面,瓶颈在IO,用单线程,全速的读就是最快的了.除非你在读取一行数据后要对行数据进行格式化,并且这个格式化时间消耗要大于理论上的连续读两行文本时的CPU时间. 不过恐怕不容易吧,这两个时间差好几个级.
写的部分,瓶颈还是在IO,因为你要写到数据库中.
这么算两个线程就够了,生产者消费者模式即可.
49 楼 HenryYu 2010-01-29  
<p>看看我是怎么实现的 <br><a title="http://henryyu.iteye.com/admin/blogs/374304" href="http://henryyu.iteye.com/admin/blogs/374304">http://henryyu.iteye.com/admin/blogs/374304</a></p>
<p> </p>
48 楼 zli.ray 2010-01-29  
蓝皮鼠 写道
zli.ray 写道
蓝皮鼠 写道
java的线程缺省行为就是主线程要等待所有线程完成才退出啊，不知道楼主为什么要提这个问题

模拟的场景为，在所有子线程都执行完毕后，主线程要做一些事情，比如记录时间戳等等。

这种情况用如下方法不是更简单么 
		Runtime.getRuntime().addShutdownHook(new Thread() {
			@Override
			public void run() {
				// 做你的事情。。。;
			}
		});


建议大家仔细的学习JDK自己提供的方法。。

呵呵，还有这种巧妙地用法，受教！
不过，看了一下addShutdownHook的javadoc，感觉它有一些局限性。
addShutdownHook添加的关闭挂钩，是在java虚拟机关闭前执行，但是，有些时候，子线程运行完毕后，并不期望程序退出，可能还有其它的任务，甚至有可能程序是一个长时间运行的服务器，那就更不可能随便停止了。这种情况下，关闭挂钩就无能为力了，而CountDownLatch则没有这种限制，较之灵活性更强。不知理解的对不对。
47 楼 yadsun 2010-01-29  
zhangdp_neu 写道
srdrm 写道
用多线程导入是失败的设计

这个算不上是失败，设计好了话也可以提高效率，但是不推荐这是首选方案。

用多线程主要是因为数据库中有xmltype类型的字段，会比较引响性能，现在看来还没有达到预期目的，现在导20w条耗时20秒左右，有没有人知道如何处理xmltype类型字段？谢了
46 楼 javaTo 2010-01-29  
<pre name="code" class="java">ExecutorService exec = Executors.newFixedThreadPool(10);
for ( ... )
    exec.execute( new Task(...) );

exec.shutdown();
try {
    exec.awaitTermination(5 * 60 * 60, TimeUnit.SECONDS);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}</pre>
45 楼 huihuilou 2010-01-28  
试着写了一个似乎和楼主需求相关的代码，请大家批评一下，是否合理。
主要是使用wait和notity来进行处理这种多个线程的问题。另外，对于其它一些多线程问题，可以使用jdk5.0中的concurrency包下的API，很好用的。Executor,Furture,Callable，在外网查一下这几个关键定，就有很多相关说明。对于控制线程的所有问题，它们都是那么的好用及稳健。 
import java.util.ArrayList;
import java.util.List;

public class ThreadMain {
	public static void main(String[] args) {
		long currentTime = System.currentTimeMillis();
		CountTool countTool = new CountTool();
		List<Runnable> taskList = new ArrayList<Runnable>();
		taskList.add(new MayTask(countTool, 1)); //1代表秒
		taskList.add(new MayTask(countTool, 2));
		taskList.add(new MayTask(countTool, 3));
		taskList.add(new MayTask(countTool, 4));
		countTool.start(taskList);
		System.out.println("I am main thread, after others is ok. time is " + (System.currentTimeMillis()-currentTime));
	}
}
/**
 *启动任务，并管理任务是否都已经完成 
 */
class CountTool {
	private Object ob = new Object();
	
	private int countNum;
	private int countNumDest;
	public CountTool() {
	}
	/**
	 *主线程调用，将任务对象放到一个列表中，在方法每个任务创建一个线程执行任务
	 *如果执行完成后，执行结果完成数加1,并且判断是否已经达到执行完成的总数，是则唤醒主线程
	 * @param <T>
	 * @param task
	 */
	public void start(List<Runnable> taskList) {
		countNum = taskList.size();
		synchronized (ob) {
			for (Runnable task : taskList) {
				new Thread(task).start();
			}
			try {
				ob.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	public void oneOk() {
		synchronized (ob) {
			if (++countNumDest >= countNum) {
			    ob.notify();
			}
		}
	}
}
/**
 * 具体执行任务
 */
class MayTask implements Runnable{
	private CountTool countTool;
	private int sleepTime;
	public MayTask(CountTool countTool, int sleepTime) {
		this.countTool = countTool;
		this.sleepTime = sleepTime * 1000;
	}
	public void run() {
		try {
			System.out.println("Current thread name is" + Thread.currentThread().getName() + "i will sleep " + sleepTime);
			Thread.currentThread().sleep(sleepTime);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		countTool.oneOk();
	}
}
44 楼 蓝皮鼠 2010-01-28  
zli.ray 写道
蓝皮鼠 写道
java的线程缺省行为就是主线程要等待所有线程完成才退出啊，不知道楼主为什么要提这个问题

模拟的场景为，在所有子线程都执行完毕后，主线程要做一些事情，比如记录时间戳等等。

这种情况用如下方法不是更简单么 
		Runtime.getRuntime().addShutdownHook(new Thread() {
			@Override
			public void run() {
				// 做你的事情。。。;
			}
		});


建议大家仔细的学习JDK自己提供的方法。。
43 楼 zhaoyta 2010-01-28  
用FileChinnel 锁定文件的不同块，然后通过MapByteBuffer做内存映射文件，然后多线程处理

前提是要有大的内存
也可以分步
42 楼 aoliwen521 2010-01-28  
zli.ray 写道
又一个轮子。
用java.util.concurrent.CountDownLatch就可以了。

即使在1.4中，CountDownLatch用不了，lz的代码里主线程的while循环中，至少应该sleep一下，不然很耗吧。

同意。
感觉设置一个线程计数器，主线程先wait()，子线程执行完毕操作计数器，并判断是否需要notify()。似乎也可以实现。
41 楼 zhangdp_neu 2010-01-28  
srdrm 写道
用多线程导入是失败的设计

这个算不上是失败，设计好了话也可以提高效率，但是不推荐这是首选方案。
40 楼 yadsun 2010-01-28  
yadsun 写道
ftj20003 写道
    有一个个人观点：第一个版本的声明为static的类变量runningThreads的访问并不是线程安全的，代码：
public synchronized void regist(Thread t){  
 runningThreads.add(t);
}

这个synchronized的作用是使用ImportThread实例的锁，而不是类对象的锁，所以主线程中：
for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程  
 Thread t = new ImportThread();  
 t.start();  
}

进入regist()方法几乎是同时的，也就是对runningThreads的操作几乎是同时的。因为每个线程都是获得自己实例的锁，没有任何竞争关系，这就在高并发的情况下使得ArrayList的结构可能被破坏。可以通过实验代码测试：
public synchronized void regist(Thread t){
 System.out.println(Thread.currentThread().getName() + " will sleeping.");
 try {
     Thread.sleep(3000);
 }
 catch (InterruptedException e) {
     e.printStackTrace();
 }
 runningThreads.add(t);
}

这里可以看到持有锁的线程进入睡眠时并没有排斥其他线程的进入，也就是主程序启动的子线程之间并不构成竞争，打印语句几乎同时执行。所以要想使得类变量被安全的访问要在所有的访问方法上使用类对象的锁，也就是所有相应的方法使用public static synchronized声明。这样所有的子线程在访问runningThreads的时候会竞争类对象的锁，达到对类变量的安全访问。
    以上仅个人观点，仅供参考。

是的，锁应该加在参数Thread t上或者方法是static的，谢谢

sorry,是加在runningThreads上
39 楼 yadsun 2010-01-28  
ftj20003 写道
    有一个个人观点：第一个版本的声明为static的类变量runningThreads的访问并不是线程安全的，代码：
public synchronized void regist(Thread t){  
 runningThreads.add(t);
}

这个synchronized的作用是使用ImportThread实例的锁，而不是类对象的锁，所以主线程中：
for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程  
 Thread t = new ImportThread();  
 t.start();  
}

进入regist()方法几乎是同时的，也就是对runningThreads的操作几乎是同时的。因为每个线程都是获得自己实例的锁，没有任何竞争关系，这就在高并发的情况下使得ArrayList的结构可能被破坏。可以通过实验代码测试：
public synchronized void regist(Thread t){
 System.out.println(Thread.currentThread().getName() + " will sleeping.");
 try {
     Thread.sleep(3000);
 }
 catch (InterruptedException e) {
     e.printStackTrace();
 }
 runningThreads.add(t);
}

这里可以看到持有锁的线程进入睡眠时并没有排斥其他线程的进入，也就是主程序启动的子线程之间并不构成竞争，打印语句几乎同时执行。所以要想使得类变量被安全的访问要在所有的访问方法上使用类对象的锁，也就是所有相应的方法使用public static synchronized声明。这样所有的子线程在访问runningThreads的时候会竞争类对象的锁，达到对类变量的安全访问。
    以上仅个人观点，仅供参考。

是的，锁应该加在参数Thread t上或者方法是static的，谢谢
38 楼 zhangdp_neu 2010-01-28  
"关键在于性能" 的话，你就直接Oracle的SQLLoader方式导入,这个很快。

如果你一定要用多线程导入的话，最好针对你的线程个数设置多个 Freelist。
有助于较少锁的争用。
37 楼 ftj20003 2010-01-28  
    有一个个人观点：第一个版本的声明为static的类变量runningThreads的访问并不是线程安全的，代码： 
public synchronized void regist(Thread t){  
 runningThreads.add(t);
}

这个synchronized的作用是使用ImportThread实例的锁，而不是类对象的锁，所以主线程中： 
for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程  
 Thread t = new ImportThread();  
 t.start();  
}

进入regist()方法几乎是同时的，也就是对runningThreads的操作几乎是同时的。因为每个线程都是获得自己实例的锁，没有任何竞争关系，这就在高并发的情况下使得ArrayList的结构可能被破坏。可以通过实验代码测试： 
public synchronized void regist(Thread t){
 System.out.println(Thread.currentThread().getName() + " will sleeping.");
 try {
     Thread.sleep(3000);
 }
 catch (InterruptedException e) {
     e.printStackTrace();
 }
 runningThreads.add(t);
}

这里可以看到持有锁的线程进入睡眠时并没有排斥其他线程的进入，也就是主程序启动的子线程之间并不构成竞争，打印语句几乎同时执行。所以要想使得类变量被安全的访问要在所有的访问方法上使用类对象的锁，也就是所有相应的方法使用public static synchronized声明。这样所有的子线程在访问runningThreads的时候会竞争类对象的锁，达到对类变量的安全访问。
    以上仅个人观点，仅供参考。
36 楼 magician 2010-01-28  
oaklet 写道
java线程是能并发了！
oracle数据库是并发入库的吗。


去好好学习一下Oracle的并行度机制
35 楼 蜗牛创业网 2010-01-28  
火车头那本书 《JAVA并发编程实践》里面讲了闭锁的用法，可以看一下
34 楼 zli.ray 2010-01-28  
蓝皮鼠 写道
java的线程缺省行为就是主线程要等待所有线程完成才退出啊，不知道楼主为什么要提这个问题

模拟的场景为，在所有子线程都执行完毕后，主线程要做一些事情，比如记录时间戳等等。
33 楼 蓝皮鼠 2010-01-28  
java的线程缺省行为就是主线程要等待所有线程完成才退出啊，不知道楼主为什么要提这个问题
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java多线程--等待所有子线程执行完的五种方法.docx

    在Java多线程编程中，有时我们需要确保所有子线程执行完毕后再进行后续操作，例如在并发测试、数据聚合或资源清理等场景。本篇文章将详细介绍五种在Java中等待所有子线程执行完的方法。 ### 方法一：使用`sleep`...

    Java多线程--让主线程等待所有子线程执行完毕在执行

    在Java多线程编程中，有时我们需要确保主线程在所有子线程完成执行后再继续执行。这在处理大量并发任务，比如数据导入、并行计算等场景中是常见的需求。以下是如何实现这一功能的详细解释。 首先，让我们理解为什么...

    Java主线程等待子线程执行完毕

    Java 主线程等待子线程执行完毕 Java 中的多线程编程是非常重要的一部分，特别是在需要并发执行多个任务的情况下。然而，在某些情况下，我们需要等待所有子线程执行完毕后再继续执行主线程的剩余动作。这时，我们...

    Java多线程–让主线程等待所有子线程执行完毕

    要解决“让主线程等待所有子线程执行完毕”的问题，可以采用以下策略： 1. 使用`join()`方法：如提到的，直接在每个子线程的`start()`之后调用`t.join()`，会导致所有线程按顺序执行。这是因为`join()`会让主线程...

    Java简单实现“主线程等待所有子线程完成再继续”

    总的来说，Java提供了丰富的多线程同步机制，可以根据实际需求选择合适的方法来实现“主线程等待所有子线程完成再继续”的功能。在并发编程中，理解并灵活运用这些工具对于提高程序效率和避免死锁等问题至关重要。

    主线程等待子多线程(无结果返回)执行完成再继续执行

    在多线程编程中，有时我们需要确保主线程在所有子线程执行完毕后才继续执行。这通常是为了保证数据的一致性或者按照特定顺序完成任务。"主线程等待子多线程(无结果返回)执行完成再继续执行"这个主题就涉及到如何在...

    Python多线程:主线程等待所有子线程结束代码

    本篇文章将深入探讨如何在Python中实现多线程，并让主线程等待所有子线程结束。 首先，我们需要了解Python中的`threading`模块，它是Python标准库中用于处理多线程的模块。在示例代码中，我们创建了两个函数`a()`和...

    java多线程编程 在主线程main中创建两个子线程

    自己学着编写的一个JAVA多线程程序，该程序实现的功能是：在主线程main中创建两个子线程，A和B，线程A先运行，再运行B线程，当两个子线程都运行完毕后，才运行主线程，并最终结束整个程序的运行。 希望该程序对初学...

    多线程执行完后主程序再执行（包括需要子线程返回结果）

    为解决这个问题，我们需要使用同步机制，如Java中的`join()`方法或C#的`Thread.Join()`，让主线程等待所有子线程完成后再继续执行。当调用`join()`方法时，主线程会被阻塞，直到被调用的线程执行完毕。 例如，在...

    JAVA100例之实例62JAVA多线程

    // 主线程等待thread1执行完毕 thread1.join(); ``` **异常处理**： 在多线程环境中，每个线程都有自己的异常处理机制。主线程不会捕获子线程抛出的异常，因此在子线程中需要妥善处理异常，避免程序意外终止。 总...

    java多线程

    1. **主线程等待子线程完成**：在多线程环境中，主线程有时需要等待所有子线程执行完毕后才进行后续处理，如清理资源或汇总子线程的计算结果。 2. **线程间数据同步**：当一个线程依赖于另一个线程产生的数据时，...

    Java线程之join_动力节点Java学院整理

    然后调用`s.join()`，这就意味着主线程会暂停执行，直到子线程`s`执行完毕。这种行为确保了子线程的操作先于主线程的后续操作完成。 在`join()`方法的源码分析中，我们可以看到两个重载版本：一个不带参数，一个带...

    Java软件开发实战 Java基础与案例开发详解 12-1 多线程 共18页.pdf

    线程是程序执行流的最小单元，一个标准的程序只能执行一个任务，而使用多线程技术可以让程序同时执行多个任务，从而提高程序的性能。 #### 2. 线程与进程的区别 - **进程**：每个进程都有独立的代码和数据空间（即...

    java课件， 包含多线程

    当主线程结束时，所有由主线程创建的子线程也将随之结束。这是Java虚拟机（JVM）的行为，确保了程序的整洁关闭。 #### 4. 线程的终止 除了自然结束外，线程还可以通过调用`stop()`方法强制停止。然而，此方法已被...

    Java软件开发实战 Java基础与案例开发详解 12-2 线程的生命周期 共10页.pdf

    2. **主线程等待子线程**：接着，主线程通过调用`join()`方法等待子线程执行完毕。 3. **子线程执行完毕**：子线程执行完毕后，主线程继续执行后续逻辑。 通过这种方式，我们可以清晰地控制线程之间的执行顺序。 ...

    多线程countDownLatch方法介绍

    在Java多线程编程中，CountDownLatch是一个非常重要的同步工具类，它可以帮助我们协调多个线程之间的交互。本文将深入探讨CountDownLatch的工作原理、使用场景以及相关源码分析。 CountDownLatch是一个计数器，初始...

    java多线程读取多个文件的方法

    8. 调用`countDownLatch.await()`，主线程会阻塞等待直到所有子线程执行完毕。 需要注意的是，为了确保线程安全，文件读取和重命名操作应当采取措施避免冲突，例如可以在读取文件时使用文件锁机制，或是在重命名...

    Java线程知识总结

    每个Java应用程序至少有一个线程，称为主线程，它是程序执行的起点。线程的创建通常是通过实现`Runnable`接口或者继承`Thread`类来完成的。一旦创建了线程，可以通过调用`start()`方法启动它，这将使得线程进入就绪...

Magicbox
Global site tag (gtag.js) - Google Analytics