这篇文章主要讲解了“多线程执行的过程”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“多线程执行的过程”吧！

创新互联建站坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站制作、网站设计、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的仪陇网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

1、主线程等待子线程执行完成后再执行——Thread.join()

Vector vector = new Vector<>(10);
		for (int i = 0; i < 10; i++) {
			MyThread myThread = new MyThread("id" + i, "name" + i, roles);
			Thread t = new Thread(myThread);
			vector.add(t);
			t.start();
		}
		for (Thread thread : vector) {
			try {
				thread.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

2、Java多线程--让主线程等待子线程执行完毕（CountDownLatch类）

Runable接口实现类

import com.winning.jcfw.core.util.SpringUtil;
import com.winning.jcfw.empi.dao.DaGrJbxxDao;
import com.winning.jcfw.empi.entity.PatientEntity;
import com.winning.jcfw.empi.service.RegisterEmpiService;
import com.winning.jcfw.empi.service.impl.RegisterEmpiSerImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;

import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * @ClassName DaGrJbxxEmpiRunnable
 * @Description 公卫表 DA_GR_JBXX 线程执行单条生成EMPI
 * @Author WJX
 * @Date 2019/10/25 17:45
 **/
@Slf4j
public class DaGrJbxxEmpiRunnable implements Runnable{

    private RegisterEmpiService registerEmpiService = SpringUtil.getBean(RegisterEmpiSerImpl.class);

    private DaGrJbxxDao daGrJbxxDao = SpringUtil.getBean(DaGrJbxxDao.class);

    private CountDownLatch dLatch;

    /**
     * 机构代码集合
     */
    private List jgList;

    public DaGrJbxxEmpiRunnable(List threadJgLsit,CountDownLatch downLatch){
        super();
        jgList = threadJgLsit;
        dLatch = downLatch;
    }

    @Override
    public void run() {

        for(int i=0;i
调用接口实现类
import com.winning.jcfw.empi.dao.DaGrJbxxDao;
import com.winning.jcfw.empi.service.DaGrJbxxService;
import com.winning.jcfw.empi.thread.DaGrJbxxEmpiRunnable;
import com.winning.jcfw.empi.util.ConvertListUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @ClassName DaGrJbxxSerImpl
 * @Description TODO
 * @Author WJX
 * @Date 2019/10/28 14:53
 **/
@Service
@Slf4j
public class DaGrJbxxSerImpl implements DaGrJbxxService {

    @Autowired
    private DaGrJbxxDao daGrJbxxDao;

    @Override
    public void handleData(int perListCount) {
        int totalCount = daGrJbxxDao.getCount();
        log.info("公卫表 DA_GR_JBXX 表待生成记录：" + totalCount + "条数据");
        //机构集合
        List jgList = daGrJbxxDao.getJgCount();
        //线程机构集合
        List> threadjgList = ConvertListUtils.getjgLsit(jgList,perListCount);
        int threadCount = threadjgList.size();
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        //创建计数器对象，此处构造器传入的int类型实参，必须与下文需要的创建的子线程个数相同。
        CountDownLatch latch = new CountDownLatch(threadCount);
        for(int k=0;k yldmList = threadjgList.get(k);
            Runnable daGrJbxxEmpiRunnable = new DaGrJbxxEmpiRunnable(yldmList,latch);
            Thread daGrJbxxEmpiThread = new Thread(daGrJbxxEmpiRunnable);
            executor.execute(daGrJbxxEmpiThread);
        }

        try {
            latch.await();//保证之前的所有的线程都执行完成，才会走下面的
        } catch (InterruptedException e) {
            log.info("线程执行异常",e);
        }
    }
}
CountDownLatch源码解析：
/**
     * Constructs a {@code CountDownLatch} initialized with the given count.
     *
     * @param count the number of times {@link #countDown} must be invoked
     *        before threads can pass through {@link #await}
     * @throws IllegalArgumentException if {@code count} is negative
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }
await方法
/**
     * Causes the current thread to wait until the latch has counted down to
     * zero, unless the thread is {@linkplain Thread#interrupt interrupted}.
     *
     * 
If the current count is zero then this method returns immediately.
     *
     * 
If the current count is greater than zero then the current
     * thread becomes disabled for thread scheduling purposes and lies
     * dormant until one of two things happen:
     * 

     * 
The count reaches zero due to invocations of the
     * {@link #countDown} method; or
     * 
Some other thread {@linkplain Thread#interrupt interrupts}
     * the current thread.
     * 
     *
     * 
If the current thread:
     * 

     * 
has its interrupted status set on entry to this method; or
     * 
is {@linkplain Thread#interrupt interrupted} while waiting,
     * 
     * then {@link InterruptedException} is thrown and the current thread's
     * interrupted status is cleared.
     *
     * @throws InterruptedException if the current thread is interrupted
     *         while waiting
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
sync.acquireSharedInterruptibly(1)
/**
     * Acquires in shared mode, aborting if interrupted.  Implemented
     * by first checking interrupt status, then invoking at least once
     * {@link #tryAcquireShared}, returning on success.  Otherwise the
     * thread is queued, possibly repeatedly blocking and unblocking,
     * invoking {@link #tryAcquireShared} until success or the thread
     * is interrupted.
     * @param arg the acquire argument.
     * This value is conveyed to {@link #tryAcquireShared} but is
     * otherwise uninterpreted and can represent anything
     * you like.
     * @throws InterruptedException if the current thread is interrupted
     */
    public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }


/**
     * Acquires in shared interruptible mode.
     * @param arg the acquire argument
     */
    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
主要是parkAndCheckInterrupt()是如何将线程阻塞的
await方法使当前线程等待直到count值为0，或者当前线程被打断！如果当前的count值为0，那么await方法直接返回，当前线程不会阻塞！如果当前的count值大于0，那么当前线程阻塞（线程调度机制无法给当前线程分配CPU时间片），直到以下两种情况任意一种发生为止：
count值通过countDown方法的调用达到0 或者 其他线程打断了当前线程
/**
     * Convenience method to park and then check if interrupted
     *
     * @return {@code true} if interrupted
     */
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }
unparkSuccessor()方法唤醒线程
/**
 * Wakes up node's successor, if one exists.
 *
 * @param node the node
 */
private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}
最后我们来看一段最简单的使用park与unpark方法阻塞唤醒线程代码：
public static void main(String[] args) {

		Thread t = new Thread(() -> {
			System.out.println("阻塞线程1");
			LockSupport.park();
			System.out.println("线程1执行完啦");
		});

		t.start();

		try {
			Thread.sleep(2000);
			System.out.println("唤醒线程1");
			LockSupport.unpark(t);
			Thread.sleep(5000);
			System.out.println("主线程结束");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
阻塞线程1
唤醒线程1
线程1执行完啦
主线程结束
感谢各位的阅读，以上就是“多线程执行的过程”的内容了，经过本文的学习后，相信大家对多线程执行的过程这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是创新互联，小编将为大家推送更多相关知识点的文章，欢迎关注！
            
            
                                

                    网站名称：多线程执行的过程                    

                    本文路径：http://csdahua.cn/article/pjojpj.html