java kwic主程序与子程序 java主线程和子线程的区别

转载

jojo 2023-07-15 21:46:16

文章标签 java kwic主程序与子程序 java Powered by 金山文档主线程子线程 文章分类 Java 后端开发

主线程与子线程

主线程

当一个程序启动时，就有一个进程被操作系统(OS)创建，与此同时一个线程也立刻运行，该线程通常叫做程序的主线程(Main Thread)，因为它是程序开始时就执行的，如果你需要再创建线程，那么创建的线程就是这个主线程的子线程。每个进程至少都有一个主线程。

主线程的重要性体现在两方面：

(1)是产生其他子线程的线程;

(2)通常它必须最后完成执行比如执行各种关闭动作。

当 Java 程序启动时，一个线程会立刻运行，该线程通常叫做程序的主线程（main thread），即 main 方法对应的线程，它是程序开始时就执行的。 Java 应用程序会有一个 main 方法，是作为某个类的方法出现的。当程序启动时，该方法就会第一个自动的得到执行，并成为程序的主线程。也就是说，main 方法是一个应用的入口，也代表了这个应用的主线程。JVM 在执行 main 方法时,main 方法会进入到栈内存,JVM 会通过操作系统开辟一条 main 方法通向 cpu 的执行路径,cpu 就可以通过这个路径来执行 main 方法,而这个路径有一个名字,叫 main(主)线程

主线程的特点：

它是产生其他子线程的线程。

它不一定是最后完成执行的线程，子线程可能在它结束之后还在运行。

子线程

在主线程中创建并启动的线程，一般称之为子线程。

CountDownLatch

CountDownLatch是一种通用的同步工具，可用于许多目的。

用1的计数初始化的CountDownLatch用作简单的开/关锁存器或门:所有调用await的线程都在门处等待，直到由调用countDown的线程打开它。

初始化为N的CountDownLatch可用于使一个线程等待到N个线程完成某个操作，或者某个操作已完成N次。

CountDownLatch的一个有用属性是，它不要求调用countDown的线程在继续之前等待计数为零，它只是阻止任何线程通过await，直到所有线程都可以通过。

CountDownLatch(int count)

构造一个用给定计数初始化的CountDownLatch

await()

导致当前线程等待，直到锁存器计数到零，除非线程被中断

countDown()

减少锁存器的计数，如果计数为零，则释放所有等待线程。

CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。

使用一个计数器进行实现。计数器初始值为线程的数量。

当每一个线程完成自己任务后，计数器的值就会减一。

当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

应用场景

1、某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为new CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减1【countdownLatch.countDown()】，当计数器的值变为0时，在CountDownLatch上await()的线程就会被唤醒。

一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

2、实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计算器初始化为1，多个线程在开始执行任务前首先countdownlatch.await()，当主线程调用countDown()时，计数器变为0，多个线程同时被唤醒。

使用CountDownLatch可以控制主线程最后执行

CyclicBarrier

同步帮助允许一组线程相互等待到达一个公共的障碍点。

cyclicbarrier在涉及固定大小的线程组的程序中非常有用，这些线程必须偶尔相互等待。

这个屏障之所以被称为循环的，是因为它可以在等待的线程被释放后被重用。

CyclicBarrier支持可选的Runnable命令，该命令在每个barrier点运行一次，在队列中的最后一个线程到达之后，但在任何线程释放之前。

这个屏障动作对于在任何一方继续之前更新共享状态是有用的。

CyclicBarrier的字面意思是可循环的（Cyclic）的使用屏障（Barrier）。它主要做的事情是让一组线程到达一个屏障点（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时才会开门，所有被屏障拦截的线程才会继续干活，线程进入屏障是通过CyclicBarrier的await方法实现的。

CyclicBarrier可以使一定数量的线程反复地在屏障位置处汇集。当线程到达屏障位置时将调用await方法，这个方法将阻塞直到所有线程都到达屏障位置。如果所有线程都到达屏障位置，那么屏障将打开，此时所有的线程都将被释放。

当所有的线程都调用了 await方法，cyclicBarrier构造方法的线程才会执行，同时所有调用await方法的线程同时被唤醒，继续执行下面的操作

注意：

CyclicBarrier的构造方法，可以传入一个实现了Runnable接口的类，表示，当所有的线程都调用了await，该线程才会被被执行。

CyclicBarrier的构造方法也可以只传入一个int类型的数字，表示当所有的线程(传入的参数数字的线程)都调用了await，所有的调用了await方法的线程都会被唤醒，继续执行下面的代码。

应用场景

交替打印foo bar

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class FooBar {
    private int n;

    private CyclicBarrier cb = new CyclicBarrier(2);
    volatile boolean fooExec = true;

    public FooBar(int n) {
        this.n = n;
    }

    public void foo(Runnable printFoo) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            while (!fooExec) {
                //false的时候，bar线程在执行，foo线程在这此处空转
            }
            //打印foo
            printFoo.run();
            //设置变量
            fooExec = false;
            try {
                //线程foo到达同步点
                cb.await();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            try {
                cb.await();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
            printBar.run();
            fooExec = true;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //打印10次foo bar
        FooBar fooBar = new FooBar(10);
        Runnable printFoo = () -> {
            System.out.printf("%s\t", "foo");
        };
        Runnable printBar = () -> {
            System.out.printf("%s\n", "bar");
        };
        Thread fooThread = new Thread(() -> {
            try {
                fooBar.foo(printFoo);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread barThread = new Thread(() -> {
            try {
                fooBar.bar(printBar);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        fooThread.start();
        barThread.start();
    }
}

Semaphore

计数信号量。从概念上讲，信号量维护一组许可。如果有必要，每个人都可以获取区块，直到许可证可用，然后再获得它。每个版本添加一个许可，可能会释放一个阻塞的获取器。

但是，没有使用实际的permit对象;信号量只是保持可用数量的计数，并相应地进行操作。

Semaphore主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程的控制数量。

Semaphore是一种在多线程环境下使用的设施，该设施负责协调各个线程，以保证它们能够正确、合理的使用公共资源的设施，也是操作系统中用于控制进程同步互斥的量。Semaphore是一种计数信号量，用于管理一组资源，内部是基于AQS的共享模式。它相当于给线程规定一个量从而控制允许活动的线程数。

工作原理

以一个停车场运作为例。为了简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆不受阻碍的进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入一辆，如果又离开两辆，则又可以放入两辆，如此往复。这个停车系统中，每辆车就好比一个线程，看门人就好比一个信号量，看门人限制了可以活动的线程。假如里面依然是三个车位，但是看门人改变了规则，要求每次只能停两辆车，那么一开始进入两辆车，后面得等到有车离开才能有车进入，但是得保证最多停两辆车。对于Semaphore类而言，就如同一个看门人，限制了可活动的线程数。

semaphore和synchronize的区别：

semaphore：可以控制多个线程进入，也可以是一个线程进入代码块

synchronize：只能控制一个线程计入代码块