Java线程安全的计数器

最新推荐文章于 2024-02-25 14:17:01 发布
最新推荐文章于 2024-02-25 14:17:01 发布
阅读量1.8w 收藏 12
点赞数 5
分类专栏： JAVA Java多线程 文章标签： JAVA 线程安全 多线程 计数器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yolanda_nuonuo/article/details/38865805
版权
   一、多线程以及线程安全   
       java线程安全就是指控制多个线程对某个资源的有序访问或修改。这涉及两个很重要的概念：java的内存模型和java的线程同步机制。
      1.java的内存模型
要解决两个主要的问题：可见性和有序性
可见性： 多个线程之间是不能互相传递数据通信的，它们之间的沟通只能通过共享变量来进行
      2.线程同步
       由于同一进程内的多个线程共享内存空间，在Java中，就是共享实例，当多个线程试图同时修改某个实例的内容时，就会造成冲突，因此，线程必须实现共享互斥，使多线程同步。
       最简单的同步是将一个方法标记为synchronized，对同一个实例来说，任一时刻只能有一个synchronized方法在执行。当一个方法正在执行某个synchronized方法时，其他线程如果想要执行这个实例的任意一个synchronized方法，都必须等待当前执行synchronized方法的线程退出此方法后，才能依次执行。
       但是，非synchronized方法不受影响，不管当前有没有执行synchronized方法，非synchronized方法都可以被多个线程同时执行。
       synchronized和volatile关键字的区别：
       (1)synchronized关键字保证了多个线程对于同步块是互斥的，synchronized作为一种同步手段，解决java多线程的执行有序性和内存可见性，而volatile关键字只解决多线程的内存可见性问题;
       (2)volatile关键字是java提供的一种同步手段，只不过它是轻量级。volatile只能保证多线程的内存可见性，不能保证多线程的执行有序性。而最彻底的同步要保证有序性和可见性，例如synchronized。
       任何被volatile修饰的变量，都不拷贝副本到工作内存，任何修改都及时写在主存。因此对于Valatile修饰的变量的修改，所有线程马上就能看到，但是volatile不能保证对变量的修改是有序的。
      3.基本知识
JAVA多线程实现方式：继承Thread类、实现Runnable接口
使用哪一种：http://www.cnblogs.com/rollenholt/archive/2011/08/28/2156357.html
最好是后一种
二、实例代码
功能：编写一个线程安全的计数器，5个线程同时跑，计数到1000，输出线程名和计数直到1000
代码： 
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
* 功能：线程安全的计数器，5个线程同时跑，计数到1000，输出线程名和计数
* @author Yolanda
*
*/
public class MySafeThread implements Runnable{

     private static AtomicInteger count = new AtomicInteger(0);//线程安全的计数变量
     private int threadCount = 0;//线程编号
     private static int num = 1;

     /**
     * 功能：计数
     */
     public static void calc(){
          while((count.get())<1000)
          {
               count.incrementAndGet();//自增1,返回更新值
              System.out.println("正在运行是线程" + Thread.currentThread().getName() + ":" + count);         
          }
     }
     
     /**
     * 功能：线程运行方法，每次只能一个线程访问
     */
     public synchronized void run() {
          while(true)
          {
               try {
                    Thread.sleep(1);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }     
               MySafeThread.calc();
          }
     }
     
     public static void main(String[] args) {          
          //创建五个线程实例并启动
          for (int i = 1; i < 6; i++) {     
               Thread mySafeThread = new Thread(new MySafeThread());
               mySafeThread.start();
          }
     }     
}




结果：

 

正在运行是线程Thread-1:2

正在运行是线程Thread-4:4

正在运行是线程Thread-0:4

正在运行是线程Thread-3:2

正在运行是线程Thread-3:9

正在运行是线程Thread-3:10

正在运行是线程Thread-0:8

正在运行是线程Thread-4:7

正在运行是线程Thread-4:13

正在运行是线程Thread-4:14

正在运行是线程Thread-4:15

正在运行是线程Thread-4:16

正在运行是线程Thread-4:17

正在运行是线程Thread-4:18

正在运行是线程Thread-4:19

正在运行是线程Thread-4:20

......

正在运行是线程Thread-4:988

正在运行是线程Thread-4:989

正在运行是线程Thread-4:990

正在运行是线程Thread-4:991

正在运行是线程Thread-4:992

正在运行是线程Thread-4:993

正在运行是线程Thread-4:994

正在运行是线程Thread-4:995

正在运行是线程Thread-4:996

正在运行是线程Thread-4:997

正在运行是线程Thread-4:998

正在运行是线程Thread-4:999

正在运行是线程Thread-4:1000

正在运行是线程Thread-2:399

正在运行是线程Thread-1:398

正在运行是线程Thread-0:700

正在运行是线程Thread-3:402

===========================我是更新线==============================

看上面的结果其实是有一点不对的，前面的几个计数发生了重复，这是由于锁的位置不正确导致的。所以对这个程序重写了一下。

package com.yolanda.fun.thread;


import java.util.concurrent.atomic.AtomicInteger;


public class MySafeCalcThread1 implements Runnable {
	
	private static AtomicInteger count = new AtomicInteger(0);
	
    public synchronized static void calc() {
    	if ((count.get()) < 1000) {
    		int c = count.incrementAndGet();// 自增1,返回更新值
    		System.out.println("正在运行是线程" + Thread.currentThread().getName() + ":" + c);
    	}
			
	}
	
	public void run() {
		 while(true)
         {
			 MySafeCalcThread1.calc();
			 try {
				 Thread.sleep(0);
			 } catch (InterruptedException e) {
				 // TODO Auto-generated catch block
				 e.printStackTrace();
			 }	 
         }
		
	}


	public static void main(String[] args) {
		for (int i = 0; i < 6; i++) {
			MySafeCalcThread1 thread = new MySafeCalcThread1();
			Thread t = new Thread(thread);
			t.start();
			
		}


	}




}

然后结果就对啦，就没有重复计数的问题啦。


结果：

正在运行是线程Thread-0:1
正在运行是线程Thread-1:2
正在运行是线程Thread-0:4
正在运行是线程Thread-2:3
正在运行是线程Thread-2:7
正在运行是线程Thread-0:6
正在运行是线程Thread-0:9
正在运行是线程Thread-1:5
正在运行是线程Thread-0:12
正在运行是线程Thread-5:11
正在运行是线程Thread-3:10
正在运行是线程Thread-2:8

.......

正在运行是线程Thread-4:996
正在运行是线程Thread-4:997
正在运行是线程Thread-4:998
正在运行是线程Thread-4:999
正在运行是线程Thread-4:1000
正在运行是线程Thread-1:743
正在运行是线程Thread-3:742
正在运行是线程Thread-0:935
正在运行是线程Thread-5:884
正在运行是线程Thread-2:747


还有一种写法是这样子的~

package com.yolanda.fun.thread;


import java.util.concurrent.atomic.AtomicInteger;


public class MySafeCalcThread2 implements Runnable {
	
	private static AtomicInteger count = new AtomicInteger(0);
	
	public static void calc() {
		
		while ((count.get()) < 1000) {
			int c = 0;
			synchronized (count) {
				if ((count.get()) < 1000) {
					c = count.incrementAndGet();// 自增1,返回更新值
				}
			}
			System.out.println("正在运行是线程" + Thread.currentThread().getName() + ":" + c);
		}




	}
	
	public void run() {
		 while(true)
         {
			 MySafeCalcThread2.calc();
			 try {
				 Thread.sleep(0);
			 } catch (InterruptedException e) {
				 // TODO Auto-generated catch block
				 e.printStackTrace();
			 }	 
         }
		
	}


	public static void main(String[] args) {
		for (int i = 0; i < 6; i++) {
			MySafeCalcThread2 thread = new MySafeCalcThread2();
			Thread t = new Thread(thread);
			t.start();
			
		}


	}




}



结果：

正在运行是线程Thread-0:1
正在运行是线程Thread-3:2
正在运行是线程Thread-4:3
正在运行是线程Thread-5:4
正在运行是线程Thread-0:5
正在运行是线程Thread-0:6
正在运行是线程Thread-2:7
正在运行是线程Thread-2:8
正在运行是线程Thread-1:9
正在运行是线程Thread-2:10

........

正在运行是线程Thread-2:990
正在运行是线程Thread-2:991
正在运行是线程Thread-2:992
正在运行是线程Thread-1:993
正在运行是线程Thread-2:994
正在运行是线程Thread-0:995
正在运行是线程Thread-5:996
正在运行是线程Thread-5:997
正在运行是线程Thread-5:998
正在运行是线程Thread-5:999
正在运行是线程Thread-5:1000


============================我是更新线===============================

在此处补充一下JAVA多线程实现的两种方式

第一种：继承Thread类

package com.yolanda.fun.thread;

public class MyThread extends Thread {
	
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("线程" + Thread.currentThread().getName() + "在运行");
		}
	}

	public static void main(String[] args) {
		MyThread thread = new MyThread();
		thread.start();
		
		for (int i = 0; i < 10; i++) {
			System.out.println("线程" + Thread.currentThread().getName() + "在运行");// 线程main
		}

	}

}



结果：

线程main在运行
线程Thread-0在运行
线程main在运行
线程main在运行
线程Thread-0在运行
线程Thread-0在运行
线程main在运行
线程Thread-0在运行
线程main在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行
线程main在运行
线程main在运行
线程main在运行
线程main在运行
线程main在运行


结果分析：这里可以看到main线程和Thread-0线程交替运行。

所谓的多线程，指的是两个线程的代码可以同时运行，而不必一个线程需要等待另一个线程内的代码执行完才可以运行。对于单核CPU来说，是无法做到真正的多线程的，每个时间点上，CPU都会执行特定的代码，由于CPU执行代码时间很快，所以两个线程的代码交替执行看起来像是同时执行的一样。那具体执行某段代码多少时间，就和分时机制系统有关了。分时系统把CPU时间划分为多个时间片，操作系统以时间片为单位片为单位各个线程的代码，越好的CPU分出的时间片越小。所以看不到明显效果也很正常，一个线程打印5句话本来就很快，可能在分出的时间片内就执行完成了。所以，最简单的解决办法就是把for循环的值调大一点就可以了（也可以在for循环里加Thread.sleep方法）。


第二种：实现Runnable接口。和继承自Thread类差不多，不过实现Runnable后，还是要通过一个Thread来启动


package com.yolanda.fun.thread;

public class MyRunnable implements Runnable{

	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("线程" + Thread.currentThread().getName() + "在运行");
		}
	}
	
	public static void main(String[] args) {
		MyRunnable thread = new MyRunnable();
		Thread t = new Thread(thread);
		t.start();
		
		for (int i = 0; i < 10; i++) {
			System.out.println("线程" + Thread.currentThread().getName() + "在运行");
		}
	}

}


结果：

线程main在运行
线程Thread-0在运行
线程main在运行
线程Thread-0在运行
线程main在运行
线程Thread-0在运行
线程main在运行
线程main在运行
线程main在运行
线程main在运行
线程main在运行
线程main在运行
线程main在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行
线程Thread-0在运行


两个线程也是交替运行。


其实Thread类也是实现的Runnable接口。


两种实现方式对比的关键就在于extends和implements的对比，当然是后者好。因为第一，继承只能但继承，实现可以多实现；第二，实现的方式对比继承的方式，也有利于减小程序之间的耦合。

因此，多线程的实现几乎都是使用的Runnable接口的方式。


线程状态

虚拟机中的线程状态有六种，定义在Thread.State中：


1、新建状态NEW
new了但是没有启动的线程的状态。比如"Thread t = new Thread()"，t就是一个处于NEW状态的线程

2、可运行状态RUNNABLE
new出来线程，调用start()方法即处于RUNNABLE状态了。处于RUNNABLE状态的线程可能正在Java虚拟机中运行，也可能正在等待处理器的资源，因为一个线程必须获得CPU的资源后，才可以运行其run()方法中的内容，否则排队等待

3、阻塞BLOCKED
如果某一线程正在等待监视器锁，以便进入一个同步的块/方法，那么这个线程的状态就是阻塞BLOCKED

4、等待WAITING
某一线程因为调用不带超时的Object的wait()方法、不带超时的Thread的join()方法、LockSupport的park()方法，就会处于等待WAITING状态

5、超时等待TIMED_WAITING
某一线程因为调用带有指定正等待时间的Object的wait()方法、Thread的join()方法、Thread的sleep()方法、LockSupport的parkNanos()方法、LockSupport的parkUntil()方法，就会处于超时等待TIMED_WAITING状态

6、终止状态TERMINATED
线程调用终止或者run()方法执行结束后，线程即处于终止状态。处于终止状态的线程不具备继续运行的能力。

 

Yolanda_NuoNuo
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java线程安全的计数器简单实现代码示例
08-29
主要介绍了Java线程安全的计数器简单实现代码示例，具有一定参考价值，需要的朋友可以了解下。
java 计数器_图解 Java并发包之CountDownLatch计数器 原理
weixin_39641236的博客
12-02 199
分享自己在Java方面的所思所想，希望你看完之后能有更多更深入的了解本人微信公众号(jwfy的学习分享)，欢迎关注～关键字：AQS，CountDownLatch，countDown，await，线程无序CountDownLatch 是基于AQS共享模式特定场景开发的一种同步器，也是在JUC并发包里面的内容，通过设置一个计数器来实现的，计时器的初始化值为线程个数，当线程完成自身的任务后，计数器会进行...
java计数器代码
qq_28514075的博客
12-27 405
对象，并启动了1000个线程来并发地递增计数器的值。最后，我们等待2秒钟以确保所有线程完成操作，然后输出计数器的值。是一个线程安全的整数类，它提供了原子操作来更新整数值。在这个示例中，我们创建了一个名为。方法来递增计数器的值，以及一个。方法来获取当前计数器的值。Java计数器代码可以使用。方法中，我们创建了一个。
线程计数器（CountDownLatch）
最新发布
qq_58148854的博客
02-25 429
CountDownLatch也属于共享锁，其内部有一个int类型的属性表示可以同时并发并行的线程的数量。主线程调用await(),等待所有线程执行完毕，也就是计数器值为0，再继续执行主线程后续任务。每个任务执行完成后，调用countDown()，CountDownLatch内部计数器自减。构造CountDownLatch实例，初始化为10，表示有10个任务需要完成。🥩使用场景：等待多个线程全部执行完，再执行某个任务。🥩注意：CountDownLatch只能减不能加。同时等待N个任务执行结束。
Simple Java—Collections（一）Java高效计数器
AlbenXie的博客
11-09 579
Translate from Efficient Counter in Java Java中的高效计数器 你可能经常需要统计一段文本或数据库中某些东西（例如单词）的出现频率。在Java中，使用HashMap可以很简单的实现这么一个计数器。 这篇文章将会比较几种实现计数器的方法，最后，得出最有效率的一个。 1. 简单计数器 String s = "one two three two three three"; String[] sArr = s.split(" "); //naive appro
java多线程安全的计数器
liminghui4321的博客
11-21 433
1.示例代码 package com.multithread; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.atomic.AtomicInteger; /** * @author: liminghui * @date: 2020/11/
Java中的程序计数器
o676448的博客
08-13 720
Program Counter Regiser 程序计数器(寄存器)线程私有一块较小的内存空间, 是当前线程所执行的字节码的行号指示器，每条线程都要有一个独立的程序计数器，这类内存也称为“线程私有”的内存。正在执行 java 方法的话，计数器记录的是虚拟机字节码指令的地址（当前指令的地址）。如果还是 Native 方法，则为空。这个内存区域是唯一 一个在虚拟机中没有规定任何情况的区域。.........
java高并发系列 - 第32天：高并发中计数器的实现方式有哪些？
专搞技术的小兔子
07-17 359
LongAdder在并发量比较大的情况下，操作数据的时候，相当于把这个数字分成了很多份数字，然后交给多个人去管控，每个管控者负责保证部分数字在多线程情况下操作的正确性。先介绍一下LongAdder，说到LongAdder，不得不提的就是AtomicLong，AtomicLong是JDK1.5开始出现的，里面主要使用了一个long类型的value作为成员变量，然后使用循环的CAS操作去操作value的值，并发量比较大的情况下，CAS操作失败的概率较高，内部失败了会重试，导致耗时可能会增加。
java之并发工具类计数器（CountDownLatch）
感冒石头的博客
12-29 2211
java并发工具类1、CountDownLatch ：能够使一个或多个线程等待其他线程完成各自的工作后再执行2、CyclicBarrier ： 让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。3、Semaphore ： 用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理地使用公共资源4、Exchanger...
JAVA多线程同步计数器
qq_34434565的博客
08-16 3382
java多线程同步计算器，包含CountDownLatch、CyclicBarrier及Semaphore
Java高效计数器
weixin_34301307的博客
11-04 502
翻译人员: 铁锚 翻译时间: 2013年11月3日 原文链接: Efficient Counter in Java 我们经常使用 HashMap作为计数器(counter)来统计数据库或者文本中的某些东西. 本文将使用HashMap来实现计数器的3种不同方式进行对比。 1. 新手级计数器 如果使用这一类别的计数器,那么代码大致如下所示: String source...
浅谈java并发之计数器CountDownLatch
08-25
CountDownLatch是通过一个计数器来实现的，当我们在new 一个CountDownLatch对象的时候需要带入该计数器值，该值就表示了线程的数量。下面我们来深入了解一下吧
Awesome-Counter:一个简单的api，用于在java中创建基于时间间隔重置的线程安全计数器。 每天、每小时或每分钟重置为 0 的命名计数器。 示例用法 - 为特定应用程序保留计数器以用于记录或检查限制。 检查特定资源的使用量是否超过其每日限制并停止访问
06-14
Awesome-Counter 是一个简单的 api，用于在 java 中创建线程安全计数器，这些计数器根据不同的策略（例如手动、基于时间间隔）重置。 它允许您使用根据策略（例如每天、每小时或每分钟）重置为 0 的命名计数器创建...
java多线程代码行数计数器
09-27
代码多线程计数器，可以搜索指定后缀名的文件。最小化到托盘的时候有点问题，有的系统无法显示小图标，但是不影响使用。
详解java多线程的同步控制
01-20
目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ReadWriteLock倒计数器 CountDownLatch循环栅栏 CyclicBarrier信号量 Semaphore 线程安全 Thread Safety JMM JMM(Java Memory Model)是一种基于计算机内存...
Java线程安全计数器
m0_38018775的博客
03-29 1304
三种方式实现计数器1、简介说明 1、简介说明 这篇博客主要记录下Java在多线程情况下，集中线程安全的计数器的一个实现。主要使用了三种不同的方式实现。 synchronized方式，排它锁、独占锁、非公平锁，悲观锁 Lock方式，公平锁，非公平锁，悲观锁 CAS自旋锁，乐观锁，效率最高 代码： /** * 线程安全问题 * 计数器 */ public class Counters { /** * 利用synchronized关键字控制方法的原子性 * 排它锁、独占锁、
python线程安全的计数器_Python多线程同步Lock、RLock、Semaphore、Event实例
weixin_33722375的博客
02-10 880
一、多线程同步由于CPython的python解释器在单线程模式下执行，所以导致python的多线程在很多的时候并不能很好地发挥多核cpu的资源。大部分情况都推荐使用多进程。python的多线程的同步与其他语言基本相同，主要包含：Lock & RLock ：用来确保多线程多共享资源的访问。Semaphore ： 用来确保一定资源多线程访问时的上限，例如资源池。Event : 是最简单的线程...
java中的计数器_Java中的计数器CountDownLatch
weixin_35456296的博客
02-25 2983
对各位注意到这个帖子的朋友说一声对不起，我不是故意的测试服务器一直没关，一忙就给忘了删了.....如果有管理员看到，可以把这个阅读数什么的清零，谢谢用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被...
java多线程使用redis计数器加减安全代码
05-27
可以使用Redis的INCR和DECR命令来实现计数器的加减操作。为了保证多线程安全，可以使用Redis的事务（Transaction）来保证原子性操作。 以下是Java多线程使用Redis计数器加减安全代码的示例： ```java import redis.clients.jedis.Jedis; import redis.clients.jedis.Transaction; public class Counter { private static final String COUNTER_KEY = "my_counter"; public static void main(String[] args) { Jedis jedis = new Jedis("localhost"); // 初始化计数器 jedis.set(COUNTER_KEY, "0"); // 开启多个线程对计数器进行加减操作 for (int i = 0; i < 10; i++) { new Thread(() -> { for (int j = 0; j < 1000; j++) { increment(jedis); decrement(jedis); } }).start(); } } private static void increment(Jedis jedis) { Transaction tx = jedis.multi(); tx.incr(COUNTER_KEY); tx.exec(); } private static void decrement(Jedis jedis) { Transaction tx = jedis.multi(); tx.decr(COUNTER_KEY); tx.exec(); } } ``` 在上面的代码中，我们使用了Redis的事务来保证INCR和DECR命令的原子性操作。多个线程同时对计数器进行加减操作时，每个线程会开启一个事务，并执行INCR或DECR命令，然后提交事务，从而保证了计数器的正确性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值