精华内容
下载资源
问答
  • 利用 C++ 11 特性实现多线程计数器
    2021-05-23 07:24:56

    许多并行计算程序,需要确定待计算数据的编号,或者说,多线程间通过编号而耦合。此时,通过利用C++ 11提供的atomic_?type类型,可实现多线程安全的计数器,从而,降低多线程间的耦合,以便于书写多线程程序。

    以计数器实现为例子,演示了多线程计数器的实现技术方法,代码如下:

    //目的: 测试利用C++ 11特性实现计数器的方法

    //操作系统:ubuntu 14.04

    //publish_date: 2015-1-31

    //注意所使用的编译命令: g++ -Wl,--no-as-needed -std=c++0x counter.cpp -lpthread

    #include

    #include

    #include

    #include

    using namespace std;

    atomic_int Counter(0);

    int order[400];

    void work(int id)

    {

    int no;

    for(int i = 0; i < 100; i++) {

    no = Counter++;

    order[no] = id;

    }

    }

    int main(int argc, char* argv[])

    {

    vector threads;

    //创建多线程访问计数器

    for (int i = 0; i != 4; ++i)

    //线程工作函数与线程标记参数

    threads.push_back(thread(work, i));

    for (auto & th:threads)

    th.join();

    //最终的计数值

    cout << "final :" << Counter << endl;

    //观察各线程的工作时序

    for(int i = 0; i < 400; i++)

    cout << "[" << i << "]=" << order[i] << " ";

    return 0;

    }

    注意编译命令的参数,尤其,-lpthread

    否则,若无该链接参数,则编译不会出错,但会发生运行时错误:

    terminate called after throwing an instance of ‘std::system_error’

    what():  Enable multithreading to use std::thread: Operation not permitted

    已放弃 (核心已转储)

    更多相关内容
  • 线程计数器

    2020-04-27 22:24:41
    每当一个线程执行完毕后,计数器的值就-1,当计数器的值为0时,表示所有线程都执行完毕,然后在闭锁上等待的线程就可以恢复工作了。 构造器: //参数count为计数值 public CountDownLatch(int count) { ...

    CountDownLatch

    countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。

    是通过一个计数器来实现的,计数器的初始值是线程的数量。每当一个线程执行完毕后,计数器的值就-1,当计数器的值为0时,表示所有线程都执行完毕,然后在闭锁上等待的线程就可以恢复工作了。

    构造器:

    //参数count为计数值
    public CountDownLatch(int count) {  };  
    

    主要方法:

    //调用await()方法的线程会被挂起,它会等待直到count值为0才继续执行
    public void await() throws InterruptedException { };   
    //和await()类似,只不过等待一定的时间后count值还没变为0的话就会继续执行
    public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
    //将count值减1
    public void countDown() { };  
    

    例子:

    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.Executor;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ThreadComminication4 {
        public static void main(String[] args) {
            ExecutorService pool = Executors.newCachedThreadPool();//构建线程池
            CountDownLatch cd = new CountDownLatch(50);//构建计数器
            for (int i = 0; i < 50; i++) {
                CountRunnable runnable = new CountRunnable(cd);
                pool.execute(runnable);//线程池循环打开当前线程
            }
        }
    }
    
    class CountRunnable implements Runnable {
        private CountDownLatch countDownLatch;
        public CountRunnable(CountDownLatch countDownLatch) {//构造器,当前计数器等于里面的计数器
            this.countDownLatch = countDownLatch;
        }
        @Override
        public void run() {
            try {
                synchronized (countDownLatch) {
                    /*** 每次减少一个容量*/
                    countDownLatch.countDown();
                    System.out.println("thread counts = " + (countDownLatch.getCount()));
                }
                countDownLatch.await();//等到计数器为0时才执行接下来的语句;
                System.out.println("concurrency counts = " + (100 - countDownLatch.getCount()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    展开全文
  • java线程计数器

    2020-09-06 19:33:27
    主要记录下CountDownLatch、CyclicBarrer、Semaphore 用法 CountDownLatch 经常遇到一种场景,线程还未执行完毕,主函数执行完了,为了避免这种情况发生可以使用countDownLatch 计数器,会阻塞主函数,等待线程执行...

    前言

    主要记录下CountDownLatch、CyclicBarrer、Semaphore 用法

    CountDownLatch

    经常遇到一种场景,线程还未执行完毕,主函数执行完了,为了避免这种情况发生可以使用countDownLatch 计数器,会阻塞主函数,等待线程执行完毕后,才放行

    • 测试
    public static void main(String[] args) throws InterruptedException {
    
        CountDownLatch downLatch = new CountDownLatch(5);
    
        for (int i = 0; i < 5; i++) {
            final int num = i;
            new Thread(()->{
                System.out.println("线程"+Thread.currentThread().getName()+" "+(num+1));
                downLatch.countDown();
            },String.valueOf(num+1)).start();
        }
        downLatch.await();
    
        System.out.println("线程"+Thread.currentThread().getName()+" 执行完毕。。。");
    }
    

    在这里插入图片描述
    countDownLatch 会阻塞线程,计数器依次递减,减到0时,放行,执行后续代码

    CyclicBarrer

    加方计数器,与CountDownLatch 想反,当满足某种条件时才执行后续步骤

    • 测试
    public static void main(String[] args) {
    
    CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
        System.out.println("放行 cyclicBarrier...");
    });
    
    for (int i = 0; i < 5; i++) {
        final int num = i;
        new Thread(() -> {
            System.out.println("线程" + Thread.currentThread().getName());
            try {
                cyclicBarrier.await(); //执行一次,+1,阻塞等待,达到计数器后,解除阻塞
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        },String.valueOf(num + 1)).start();
    
    
        System.out.println("等待执行:"+cyclicBarrier.getNumberWaiting());
    }
    

    在这里插入图片描述
    CyclicBarrer未达到设置的数量时,cyclicBarrier.await() 一直会阻塞,达到后放行,

    Semaphore

    信号量计数器,一次只能是指定个数线程,其他线程等待,线程释放后,其他线程才可进入,常用场景限流

    • 测试
    public static void main(String[] args) {
    
       Semaphore semaphore = new Semaphore(2);  //通行信号量 
    
        for (int i = 0; i < 6; i++) {
            final int num = i;
            new Thread(() -> {
                try {
                    semaphore.acquire(); //获取控制权信号量-1
                    System.out.println("线程" + Thread.currentThread().getName() + "获得控制权");
                   System.err.println("线程" + Thread.currentThread().getName() + "释放控制权");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release(); //释放控制权,信号量 +1
                }
            },String.valueOf(num+1)).start();
        }
    }
    

    在这里插入图片描述

    设置一次通行2个线程,6个线程,只有其他线程放弃控制权,后续线程才可获得

    总结

    • CountDownLatch:减法计数器,归零后解除阻塞
    • CyclicBarrer: 加法计数器,达到设定值,解除阻塞,放行
    • Seamphore: 信号量计数器,一次执行通过指定线程,线程获取信后,信号量-1,归零时阻塞,释放后,信号量后+1,信号量>0时不阻塞。
    展开全文
  • 每当一个线程执行完毕后,计数器的值就-1,当计数器的值为0时,表示所有线程都执行完毕,然后在闭锁上等待的线程就可以恢复工作了。 二、CountDownLatch类中常用方法 void await() 使当前线程在锁存器倒计数至零...

    一、CountDownLatch的理解

    • CountDownLatch属于java.util.concurrent包下;
    • CountDownLatch类使一个线程等待其他线程各自执行完毕后再执行;
    • 是通过一个计数器来实现的,计数器的初始值是线程的数量。每当一个线程执行完毕后,计数器的值就-1,当计数器的值为0时,表示所有线程都执行完毕,然后在闭锁上等待的线程就可以恢复工作了。

    二、CountDownLatch类中常用方法

    在这里插入图片描述

    • void await() 使当前线程在锁存器倒计数至零之前一直等待,除非线程被中断。
    • countDown() 递减锁存器的计数,如果计数到达零,则释放所有等待的线程。

    三、CountDownLatch类代码示例

    1、示例场景

     * 多个线程执行,每个线程计算文件中每行数据的总和
     * 汇总线程等待多个线程计算出结果后,在把所有结果进行汇总求和
     *      例如:线程0计算第一行数据值的和,
     *           线程1计算第二行数据值的和,
     *           线程2计算第三行数据值的和,
     *           汇总线程把线程0、线程1、线程2分别计算出的总和进行汇总求和
     *      文件指:在D盘创建test.txt文件,文件内容如下:
     *           13, 56, 123, 49, 89
     *           59,20,18,34,56,103
     *           123,342,56,78,68,84,99,28
    

    2、代码示例

    package com.xz.thread.CountDownLatch;
    
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    
    /**
     * @description:  多个线程执行,每个线程计算文件中每行数据的总和
     *                汇总线程等待多个线程计算出结果后,在把所有结果进行汇总求和
     *                例如:线程0计算第一行数据值的和,
     *                     线程1计算第二行数据值的和,
     *                     线程2计算第三行数据值的和,
     *             在D盘创建test.txt文件,文件内容如下:
     *             13, 56, 123, 49, 89
     *             59,20,18,34,56,103
     *             123,342,56,78,68,84,99,28
     * @author: xz
     * @create: 2021-05-30 15:33
     */
    public class Demo {
        //定义一个数组
        private int[] arrs;
    
        //构造方法,传入文件内容的行数为参数,有几行数据就声明多大的数组
        public Demo(int line){
            arrs =new int[line];
        }
    
        /**
         * 计算方法(每行数据的值求和)
         */
        public void calculate(String line,int index,CountDownLatch latch){
            //用逗号切分每一个值
            String[] split = line.split(",");
            //遍历求每行的数据总和
            int sum=0;
            for(String str:split){
                sum += Integer.parseInt(str);
            }
            //每行的数据总和赋值到声明的arrs数组中指定位置
            arrs[index] = sum;
            System.out.println(Thread.currentThread().getName()+" 执行计算任务-------"+line+" 结果="+sum);
            latch.countDown();//递减锁存器的计数,如果计数到达零,则释放所有等待的线程。
        }
    
        /**
         * 每行数据的和相加,求出总和
         */
        public void totalSum(){
            System.out.println("汇总线程【开始执行】========");
            int total=0;
            for(int i=0;i<arrs.length;i++){
                total += arrs[i];
            }
            System.out.println("汇总线程【执行完毕】========,最终结果="+total);
        }
    
        /**
         * 读取文件内容方法
         * @return
         */
        private static List<String> readFiles(){
            List<String> contents =new ArrayList<>();
            String line = null;
            BufferedReader br =null;
            try {
                br=new BufferedReader(new FileReader("D://test.txt"));
                while((line = br.readLine()) !=null){
                    contents.add(line);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    if(br !=null){
                        br.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return contents;
        }
        
    	//主方法,测试用
        public static void main(String[] args) {
            //读取文件内容
            List<String> contents =readFiles();
            //获取文件内容的行数
            int lineCount=contents.size();
            //实例化CountDownLatch,并传入内容的行数
            CountDownLatch latch =new CountDownLatch(lineCount);
    
            Demo d =new Demo(lineCount);
    
            //有几行就创建几个线程
            for(int i=0;i<lineCount;i++){
                final int j=i;
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        d.calculate(contents.get(j),j,latch);
                    }
                }).start();
            }
            //使当前线程在锁存器倒计数至零之前一直等待
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            d.totalSum();
        }
    }
    
    

    2、运行main函数,输出结果如下:

    在这里插入图片描述

    展开全文
  • CountDownLatch(线程计数器) CountDownLatch 类位于 java.util.concurrent 包下,利用它可以实现类似计数器的功能。比如有一个任务 A,它要等待其他 4 个任务执行完毕之后才能执行,此时就可以利用 CountDownLatch...
  • CountDownLatch 用来计数,设置初始值,当计数器执行完成后,执行主线程必须子线程执行完之后主线程才执行,倒计数计数器/** ... * 线程计数器 */ public class CountDownLatchDemo { public static void m...
  • 在工作中有需求任务: 开启多个多线程,等多线程跑完之后执行插入操作。对于此需求,打算利用多线程的join()关键字来实现。代码如下: PrincThread a = new PriceThread(A); a.start(); PrincThread b = new ...
  • [Java] 多线程计数器

    2020-03-20 00:02:45
    本文介绍了 [Java] 多线程计数器的应用案例。。。
  • JUC学习,CountDownLatch(线程计数器) 线程 和 Enum(枚举) package com.zhangye; import java.util.concurrent.CountDownLatch; public class CountDownLatchTest { public static void main(String[] args)...
  • Awesome-Counter 是一个简单的 api,用于在 java 中创建线程安全计数器,这些计数器根据不同的策略(例如手动、基于时间间隔)重置。 它允许您使用根据策略(例如每天、每小时或每分钟)重置为 0 的命名计数器创建...
  • Java多线程编程-(1)-线程安全和锁Synchronized概念 Java多线程编程-(2)-可重入锁以及Synchronized的其他基本特性 Java多线程编程-(3)-从一个错误的双重校验锁代码谈一下volatile关键字 Java多线程...
  • 信号量(Semaphore)与线程计数器(CountDownLatch)

    多人点赞 热门讨论 2022-04-09 19:40:34
    本文介绍了共享锁中的信号量(Semaphore)和线程计数器(CountDownLatch),从各自的构造方法与常用方法出发,介绍了各自的用法及应用场景,并分别用代码实现示例进一步介绍说明他们的用法
  • 主要介绍了Java线程安全的计数器简单实现代码示例,具有一定参考价值,需要的朋友可以了解下。
  • Java线程安全计数器

    2021-03-29 00:37:10
    这篇博客主要记录下Java在多线程情况下,集中线程安全的计数器的一个实现。主要使用了三种不同的方式实现。 synchronized方式,排它锁、独占锁、非公平锁,悲观锁 Lock方式,公平锁,非公平锁,悲观锁 CAS自旋锁,...
  • 同时开始5个线程,用各自的文本框显示count,和按钮控制count的自加import java.awt.*;import java.awt.event.*;import java.applet.*;class Ticker extends Thread{private Button t=new Button("toggle");private ...
  • 简介:CountDownLatch 是一个非常实用的多线程控制工具类,通常用来...await:使当前线程阻塞,等待计数器为 0countDown:计数器减一,计数为零时,释放所有在等待的线程实例:public class CountDownLatchDemo i...
  • 利用C++ 11特性实现多线程计数器

    千次阅读 2015-01-31 03:29:41
    许多并行计算程序,需要确定待计算数据的编号,或者说,多线程间通过编号而耦合。此时,通过利用C++ 11提供的atomic_?type类型,可实现多线程...以计数器实现为例子,演示了多线程计数器的实现技术方法,代码如下:
  • 线程协作免不了使用计数器,c++一般会使用锁,或者原子变量操作, std::mutex mutexCounter; int count; void add() { std::lock_guard<std::mutex> guard(mutexCounter); count ++; } std::atomic&...
  • 关于线程计数器

    2021-04-21 09:55:27
    关于线程计数器 Maven工程: 【前提】得有这个: // 计数器 public class CountDownLatchDemo { //InterruptedException出现一般都是因为在线程执行的时候被打断(interrupt),线程(A)不是自己打断自己,一般都是...
  • 线程下的计数器

    2021-04-27 14:48:44
    juc是java的核心包,而juc下面的核心包之一应该就是locks了,而locks下最核心的类就是AbstractQueuedSynchronizer类(简称aqs),它可以说是多线程下所有锁相关类的父类,我们来看看它有多少子类。 可以看到有...
  • CountDownLatch 线程计数器 public static void main(String[] args) throws InterruptedException { int count = 5; //线程计数器 CountDownLatch countDownLatch = new CountDownLatch(count); for (int i = 0...
  • 开3个固定大小的线程池,不断往里面加任务,每个线程共用一个计数器,争抢计数,从1开始递增。 package com.demo.thread; import java.util.concurrent.atomic.AtomicInteger; public class MyCounter { ...
  • Go包速度提供了一个线程安全计数器,用于在指定的时间内测量刻度。
  • 程序计数器为什么是线程私有的? 1.程序计数器 1.1.程序计数器的本质 从本质来看,程序技术器就是一块比较小的内存空间。 1.2.程序计数器的作用 程序计数器可以看作是当前线程所执行字节码的行号指示器,也就是...
  • ThreadPoolExecutor/ExecutorService:线程池,使用线程池可以复用线程,降低频繁创建线程造成的性能消耗,同时对线程的创建、启动、停止、销毁等操作更简便。 CountDownLatch是在java1.5被引入的,跟它一起被引入的...
  • 使用CountDownLatch线程计数器 ThreadPoolExecutor/ExecutorService:线程池,使用线程池可以复用线程,降低频繁创建线程造成的性能消耗,同时对线程的创建、启动、停止、销毁等操作更简便。 CountDownLatch是在java...
  • CountDownLatch--等待多线程计数器

    千次阅读 2019-05-21 11:18:28
    其实个人理解,他就是--等待多线程计数器! 即:在某线程中(主线程或其他分线程都可以)声明一个初始值为N的CountDownLatch计数器,然后等待多个子线程完成了相关操作后再继续向下执行。--当各子线程执行到相应的...
  • 线程访问全局变量,对同一全局变量... * 这个是实现计数器操作,主线程等待子线程全部完成 * 模拟场景:10个人赛跑,当所有的人到达终点后,比赛结束 * @author zhangm * */ public class TestCountDownLatch {
  • CountDownLatch是多线程控制的一种工具,它被称为门阀、计数器或者闭锁。这个工具经常用来用来协调多个线程之间的同步,使一个线程等待其他线程各自执行完毕后再执行。 CountDownLatch是在Java1.5被引入,存在于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 201,318
精华内容 80,527
关键字:

线程计数器

友情链接: liblinear_train.rar