Java并发控制synchronized与AtomicInteger类

最新推荐文章于 2024-09-02 15:19:29 发布

张小鸣

最新推荐文章于 2024-09-02 15:19:29 发布

阅读量4.6k

点赞数

分类专栏： Java 文章标签： AtomicInteger synchronized 并发处理线程安全线程同步

本文链接：https://blog.csdn.net/Roy_70/article/details/53160343

版权

Java 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

众所周知，在Java多线程编程中，一个非常重要的方面就是线程的同步问题。关于线程的同步，最常用的解决方法就是使用synchronized关键字，但是如果使用场景只用在控制一个计数的整型变量时(通常这也是非常常见的一个使用场景)，另一种实现方式AtomicInteger类简洁易用的特性一定会让你对它爱不释手。
我们先通过一个简单的例子模拟下多线程并发计数，程序如下

public class ShareData {
	public static int count=0;
	public static void main(String[] args){
		final ShareData data  = new ShareData();
		for(int i=0;i<10;i++){
			new Thread(
					new Runnable(){
						public void run(){
							try{
								Thread.sleep(1);
							}catch(InterruptedException e){
								e.printStackTrace();
							}
							for(int j=0;j<100;j++){
								data.addCount();
							}
							System.out.print(count+" ");
						}
					}
				).start();				
		}
		try{
			Thread.sleep(3000);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.print("count="+count);
	}
	public void addCount(){
		count++;
	}
}

程序启动了十个线程，每个线程计100次数，操作的都是count这个变量，最后在等待3秒（所有线程均执行结束后）输出此时的count值，每次执行后的输出结果都不一定一样，但是一般count小于1000，结果如下：

100 224 373 473 373 255 823 791 691 591 count=823

344 566 366 299 299 466 366 669 695 769 count=769

400 400 400 500 400 615 913 813 713 713 count=913

我们将addCount（）方法加上synchronized关键词修饰下，让它实现线程安全，

	public synchronized void addCount(){
		count++;
	}

再执行，结果如下：

200 200 411 677 774 864 1000 666 1000 891 count=1000

423 909 1000 428 802 512 691 706 512 914 count=1000

300 500 500 300 300 712 809 850 949 1000 count=1000

此时可以看出最终count的数值都会精确的是1000，讲完了synchronized之后我们再来看下AtomicInteger类

AtomicInteger类可以用原子方式更新的 int 值，主要用于在高并发环境下的高效程序处理，使用非阻塞算法来实现并发控制，它的方法有

//获取当前的值
public final int get()
//取当前的值，并设置新的值
public final int getAndSet(int newValue)
//获取当前的值，并自增
public final int getAndIncrement() 
//获取当前的值，并自减
public final int getAndDecrement()
//获取当前的值，并加上预期的值
public final int getAndAdd(int delta)

这里我们依然用上面的程序做例子，使用AtomicInteger类来替代synchronized方式，代码如下：

package concurrent;

import java.util.concurrent.atomic.AtomicInteger;

public class ShareData_AtomicInteger {
	static AtomicInteger count = new AtomicInteger(0);
	public static void main(String[] args){
		final ShareData_AtomicInteger data  = new ShareData_AtomicInteger();
		for(int i=0;i<10;i++){
			new Thread(
					new Runnable(){
						public void run(){
							try{
								Thread.sleep(1);
							}catch(InterruptedException e){
								e.printStackTrace();
							}
							for(int j=0;j<100;j++){
								data.addCount();
							}
							System.out.print(count.get()+" ");
						}
					}
				).start();				
		}
		try{
			Thread.sleep(3000);
		}catch(InterruptedException e){
			e.printStackTrace();
		}
		System.out.print("count="+count.get());
	}
	public void addCount(){
		count.getAndIncrement();
	}
}

执行结果如下：

495 528 604 504 987 657 741 682 1000 925 count=1000

500 500 984 823 499 733 500 495 601 1000 count=1000

409 409 436 409 700 587 600 872 988 1000 count=1000

至此结束，AtomicInteger只是concurrent下的一个整数原子操作类，该包下还有很多其他关于线程锁同步的机制，有兴趣的同学可以自行搜索下相关资料~谢谢