新写自己的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新线程是否执行完毕的实例就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持云海天教程。

在使用多线程的时候有时候我们会使用 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 }