「java线程计数器」计时器java编程

本篇文章给大家谈谈java线程计数器，以及计时器java编程对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、怎么知道java多线程都已经运行结束CountDownLatch
• 2、java并发(1)线程模型
• 3、java如何在多线程执行完后才执行其他任务

怎么知道java多线程都已经运行结束CountDownLatch

一、使用Java.util.concurrent.CountDownLatch

Java的util.concurrent包里面的CountDownLatch其实可以把它看作一个计数器，只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。

你可以向CountDownLatch对象设置一个初始的数字作为计数值，任何调用这个对象上的await()方法都会阻塞，直到这个计数器的计数值被其他的线程减为0为止。

CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这

个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个

CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个

CountDownLatch对象的计数值减到0为止。

举个例子，有三个工人在为老板干活，这个老板有一个习惯，就是当三个工人把一天的活都

干完了的时候，他就来检查所有工人所干的活。记住这个条件：三个工人先全部干完活，老板才检查。所以在这里用Java代码设计两个类，Worker代表工

人，Boss代表老板，具体的代码实现如下：

Worker类（单独的线程）：

package cn.edu.bupt.thread.threadnotify;

import java.util.Random;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

public class Worker implements Runnable

{

private CountDownLatch downLatch;

private String name;

public Worker(CountDownLatch downLatch, String name)

{

this.downLatch = downLatch;

this.name = name;

}

@Override

public void run()

{

this.doWork();

try

{

TimeUnit.SECONDS.sleep(new Random().nextInt(10));

}

catch (InterruptedException ie)

{

}

System.out.println(this.name + "活干完了！");

this.downLatch.countDown();

}

private void doWork()

{

System.out.println(this.name + "正在干活...");

}

}

Boss类（单独的线程）：

package cn.edu.bupt.thread.threadnotify;

import java.util.concurrent.CountDownLatch;

public class Boss implements Runnable

{

private CountDownLatch downLatch;

public Boss(CountDownLatch downLatch)

{

this.downLatch = downLatch;

}

@Override

public void run()

{

System.out.println("老板正在等所有的工人干完活......");

try

{

this.downLatch.await();

}

catch (InterruptedException e)

{

}

System.out.println("工人活都干完了，老板开始检查了！");

}

}

Main：

package cn.edu.bupt.thread.threadnotify;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class CountDownLatchDemo

{

public static void main(String[] args)

{

ExecutorService executor = Executors.newCachedThreadPool();

CountDownLatch latch = new CountDownLatch(3);

Worker w1 = new Worker(latch, "张三");

Worker w2 = new Worker(latch, "李四");

Worker w3 = new Worker(latch, "王二");

Boss boss = new Boss(latch);

executor.execute(boss);

executor.execute(w3);

executor.execute(w2);

executor.execute(w1);

executor.shutdown();

}

}

上例中的的ExecutorService接口和Executors类的作用类似于new Thread(Runnable r).start()的作用，就是启动一个新的线程。

java并发(1)线程模型

程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念

主要归咎于两点. 一个是由实现决定的,一个是由需求决定的.

线程由线程ID，程序计数器(PC）[用于指向内存中的程序指令]，寄存器集合[由于存放本地变量和临时变量]和堆栈[用于存放方法指令和方法参数等]组成。

以 Unix/Linux 的体系架构为例。

因为操作系统的资源是有限的，如果访问资源的操作过多，必然会消耗过多的资源，而且如果不对这些操作加以区分，很可能造成资源访问的冲突。所以，为了减少有限资源的访问和使用冲突，对不同的操作赋予不同的执行等级(有多大能力做多大的事)，用户态(User Mode)和内核态(Kernel Mode)。

运行于用户态的进程可以执行的操作和访问的资源都会受到极大的限制，而运行在内核态的进程则可以执行任何操作并且在资源的使用上没有限制。

并发 ：一个时间段内有很多的线程或进程在执行，但何时间点上都只有一个在执行，多个线程或进程争抢时间片轮流执行。

并行 ：一个时间段和时间点上都有多个线程或进程在执行。

线程有三种模型, 一对一,多对一,多对多.具体参考 一篇文章读懂Java多线程模型 , 这里只描述一对一的情况.

每个用户线程都映射到一个内核线程，每个线程都成为一个独立的调度单元，由内核调度器独立调度，一个线程的阻塞不会影响到其他线程，从而保障整个进程继续工作.

JVM 没有限定 Java 线程需要使用哪种线程模型来实现， JVM 只是封装了底层操作系统的差异，而不同的操作系统可能使用不同的线程模型，例如 Linux 和 windows 可能使用了一对一模型，solaris 和 unix 某些版本可能使用多对多模型。所以一谈到 Java 语言的多线程模型，需要针对具体 JVM 实现。

Sun JDK 1.2开始，线程模型都是基于操作系统原生线程模型来实现，它的 Window 版和 Linux 版都是使用系统的 1:1 的线程模型实现的。

java如何在多线程执行完后才执行其他任务

java.util.concurrent.CountDownLatch 这个类可以实现你所要的功能

例如：CountDownLatch latch = new CountDownLatch(5) //声明计数器为5个

Thread t = new Thread() {

public void run() {

try {

//TODO 你的应用

} catch (Exception e) {

//TODO 异常处理

}

finally {

latch.countDown(); //这句是关键

System.out.println("ok"); //5个线程都跑完后输出

}

}

};

t.start();

然后让以上操作循环五次(就是说同时开5个线程)，那么这个"ok"就会在等到这5个线程都ok后才会被输出一次。

java线程计数器的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于计时器java编程、java线程计数器的信息别忘了在本站进行查找喔。