Java并发编程基础——同步
一、synchronized 关键字
1）synchronized 锁什么？锁对象。可能锁对象包括： this， 临界资源对象，Class 类对象。如同下面例子所示；
package cn.test.juc;
public class TestSynchronized {
private int count = 0;
private Object object = new Object();
public void testSyn1() {
//锁对象（这里面是锁临界资源）
synchronized (object) {
System.out.println(Thread.currentThread().getName()
+" count =" + count++);
}
}
public void testSyn2() {
//锁当前对象
synchronized (this) {
System.out.println(Thread.currentThread().getName()
+" count =" + count++);
}
}
//锁当前对象
public synchronized void testSyn3() {
System.out.println(Thread.currentThread().getName()
+" count =" + count++);
}
}
2）如果在加锁的时候对当前对象的访问限定要求比较低的时候，建议锁某一段代码或者某一个对象；如果访问限定要求比较高的话，建议锁当前对象。简单而言就可以说是减小锁的范围。对于锁当前对象
或者
都是重量级锁，什么意思呢，“就是任意多个线程，多个资源不会被多个线程访问所影响的”
3）再看下面的例子，锁当前类的类对象的两种方式：
public class TestSynchronized02 {
private static int staticCount = 0;
//静态同步方法，锁的是当前类型的类对象（即TestSynchronized02.class）
public static synchronized void testSyn1() {
System.out.println(Thread.currentThread().getName()
+" staticCount =" + staticCount++);
}
//下面的这种方式也是锁当前类型的类对象
public static void testSyn2() {
synchronized (TestSynchronized02.class) {
System.out.println(Thread.currentThread().getName()
+" staticCount =" + staticCount++);
}
}
}
4）看一下下面一段小程序的运行结果
public class TestSynchronized03 implements Runnable{
private int count = 0;
@Override
public /*synchronized */ void run() {
System.out.println(Thread.currentThread().getName()
+" count =" + count++);
}
public static void main(String[] args) {
TestSynchronized03 testSynchronized03 = new TestSynchronized03();
for (int i = 0; i < 10 ; i++) {
new Thread(testSynchronized03, "Thread --- " + i).start();
}
}
}
我们发下下面的结果少加了一个1，这就是原子性的问题。在synchronized关键字没有使用的时候，对于变量count而言（由多个线程访问），是不能保证原子性（某一段代码从开始运行到结束不能分步执行）的，上面的代码没有使用同步，那么很显然多线程对变量进行加操作就可能会在同一时刻只进行1次加操作
5）关于同步方法和非同步方法：同步方法只影响 锁定同一个锁对象的同步方法，不影响非同步方法被其他线程调用，也不影响其他所资源的同步方法（简单理解就是锁的不是同一个资源，就不会影响）；
package cn.test.juc;
public class TestSynchronized04 {
private Object o = new Object();
//同步方法
public synchronized void m1() {
System.out.println("public synchronized void m1() start.");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("public synchronized void m1() end.");
}
public void m3() {
synchronized (o) {
System.out.println("public void m3() start.");
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("public void m3() end.");
}
}
//非同步方法
public void m2() {
System.out.println("public void m2() start.");
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("public void m2() end.");
}
public static class MyThread implements Runnable{
int i;
TestSynchronized04 testSynchronized04;
public MyThread(int i, TestSynchronized04 testSynchronized04) {
this.i = i;
this.testSynchronized04 = testSynchronized04;
}
@Override
public void run() {
if(i == 0) {
testSynchronized04.m1();
} else if(i == 1) {
testSynchronized04.m3();
} else {
testSynchronized04.m2();
}
}
}
public static void main(String[] args) {
TestSynchronized04 testSynchronized04 = new TestSynchronized04();
new Thread(new TestSynchronized04.MyThread(0, testSynchronized04)).start();
new Thread(new TestSynchronized04.MyThread(1, testSynchronized04)).start();
new Thread(new TestSynchronized04.MyThread(2, testSynchronized04)).start();
}
}
下面是运行的结果
6）脏读问题
package cn.test.juc;
import java.util.concurrent.TimeUnit;
public class TestSynchronized05 {
private double d = 0.0;
//相当与是set方法
public synchronized void m1(double d) {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.d = d;
}
//相当于是get方法
public double m2() {
return this.d;
}
public static void main(String[] args) {
final TestSynchronized05 testSynchronized05 = new TestSynchronized05();
new Thread(new Runnable() {
@Override
public void run() {
testSynchronized05.m1(100);
}
}).start();
System.out.println(testSynchronized05.m2());
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(testSynchronized05.m2());
}
}
上面代码的输出是0.0 100.00，而不是期望的100.00 100.00，出现这种情况（脏读）的原因是什么的？就是m1方法的这段代码引起的
这段代码表示睡眠2秒之后再进行set操作，使用这一段代码的原因就是模拟实际当中的复杂处理操作，可能会比较耗时，但是这时候还没执行完毕没有将正确的结果写会，别的线程就去访问临界资源的话，就会出现脏读的情况。
7）锁的可重入问题：同一个线程，多次调用同步代码，锁定同一个对象，可重入
看看下面的代码实例：main调用m1方法，m1方法中调用m2方法，两个方法锁定的都是this对象，就会是上面说到的这种情况
package cn.test.juc;
import java.util.concurrent.TimeUnit;
public class TestSynchronized06 {
synchronized void m1() { //锁this
System.out.println("m1 start()");
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
m2();
System.out.println("m1 end()");
}
synchronized void m2() { //锁this
System.out.println("m2 start()");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m2 end()");
}
public static void main(String[] args) {
new TestSynchronized06().m1();
}
}
8）关于同步的继承问题：同一个线程中，子类同步方法覆盖父类的同步方法，可以指定调用父类的同步方法（相当于锁的重入）；
package cn.test.juc;
import java.util.concurrent.TimeUnit;
public class TestSynchronized07 {
synchronized void m() {
System.out.println("Super Class m start");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Super Class m end");
}
public static void main(String[] args) {
new ExtendTest07().m();
}
}
class ExtendTest07 extends TestSynchronized07 {
synchronized void m() {
System.out.println("Sub Class m start");
super.m();
System.out.println("Sub Class m end");
}
}
9）锁与异常：当同步方法出现异常的时候会自动释放锁，不会影响其他线程的执行
package cn.test.juc;
import java.util.concurrent.TimeUnit;
public class TestSynchronized08 {
int i = 0;
synchronized void m(){
System.out.println(Thread.currentThread().getName() + " - start");
while(true){
i++;
System.out.println(Thread.currentThread().getName() + " - " + i);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(i == 5){
i = 1/0;
}
}
}
public static void main(String[] args) {
final TestSynchronized08 t = new TestSynchronized08();
new Thread(new Runnable() {
@Override
public void run() {
t.m();
}
}, "t1").start();
new Thread(new Runnable() {
@Override
public void run() {
t.m();
}
}, "t2").start();
}
}
下面是输出的结果：
10）synchronized锁的是对象，而不是引用：同步代码一旦加锁之后会有一个临时锁引用执行锁对象，和真实的引用无直接关联，在锁释放之前，修改锁对象引用不会影响同步代码块的执行
package cn.test.syn;
import java.util.concurrent.TimeUnit;
public class TestSynchronized09 {
Object o = new Object();
int i = 0;
int a(){
try{
/*
* return i ->
* int _returnValue = i; // 0;
* return _returnValue;
*/
return i;
}finally{
i = 10;
}
}
void m(){
System.out.println(Thread.currentThread().getName() + " start");
synchronized (o) {
while(true){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " - " + o);
}
}
}
public static void main(String[] args) {
final TestSynchronized09 t = new TestSynchronized09();
new Thread(new Runnable() {
@Override
public void run() {
t.m();
}
}, "thread1").start();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
t.m();
}
}, "thread2");
t.o = new Object();
thread2.start();
System.out.println(t.i);
System.out.println(t.a());
System.out.println(t.i);
}
}
11）synchronized中的常量问题：在定义同步代码块的时候，不要使用常量对象作为锁对象
package cn.test.syn;
import java.util.concurrent.TimeUnit;
public class TestSynchronized09 {
Object o = new Object();
int i = 0;
int a(){
try{
/*
* return i ->
* int _returnValue = i; // 0;
* return _returnValue;
*/
return i;
}finally{
i = 10;
}
}
void m(){
System.out.println(Thread.currentThread().getName() + " start");
synchronized (o) {
while(true){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " - " + o);
}
}
}
public static void main(String[] args) {
final TestSynchronized09 t = new TestSynchronized09();
new Thread(new Runnable() {
@Override
public void run() {
t.m();
}
}, "thread1").start();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
t.m();
}
}, "thread2");
t.o = new Object();
thread2.start();
System.out.println(t.i);
System.out.println(t.a());
System.out.println(t.i);
}
}
二、Volatile关键字
1、下面的代码在没有使用volatile之前，是不会从循环中跳出的（main线程和新创建的线程互相之间是不可见的，所以新创建的线程在使用m方法的时候并不知道main线程已经改变了b的值，所以不会跳出循环），那么使用volatile会怎样呢（简单说是可见性）但是啥是可见性：当某个线程正在使用对象状态，而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。
package cn.test.Volatile;
import java.util.concurrent.TimeUnit;
public class TestVolatile01 {
/*volatile*/ boolean b = true;
void m(){
System.out.println("start");
while(b){}
System.out.println("end");
}
public static void main(String[] args) {
final TestVolatile01 t = new TestVolatile01();
new Thread(new Runnable() {
@Override
public void run() {
t.m();
}
}).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.b = false;
}
}
2、volatile只能保证可见性，不能保证原子性，volatile不是加锁问题，只是保证内存数据可见；参照下面的例子，运行的结果不是期望的100000，而是
当然，也不一定每次都是这个值。
package cn.test.Volatile; import java.util.ArrayList;
import java.util.List; public class TestVolatile02 {
volatile int count = 0;
/*synchronized*/ void m(){
for(int i = 0; i < 10000; i++){
count++;
}
} public static void main(String[] args) {
final TestVolatile02 t = new TestVolatile02();
List<Thread> threads = new ArrayList<>();
for(int i = 0; i < 10; i++){
threads.add(new Thread(new Runnable() {
@Override
public void run() {
t.m();
}
}));
}
for(Thread thread : threads){
thread.start();
}
for(Thread thread : threads){
try {
thread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(t.count);
}
}
三、AtomicXXX
Atomic主要做的就是原子操作，其中的每个方法都是原子操作，可以保证线程安全。参照下面的例子：创建十个线程，每个线程累加100次，得到的结果就是1000
package cn.test.atomic; import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger; public class TestAtomic01 {
AtomicInteger count = new AtomicInteger(0);
void m1(){
for(int i = 0; i < 100; i++){
/*if(count.get() < 1000)*/
count.incrementAndGet();
}
} public static void main(String[] args) {
final TestAtomic01 t = new TestAtomic01();
List<Thread> threads = new ArrayList<>();
for(int i = 0; i < 10; i++){
threads.add(new Thread(new Runnable() {
@Override
public void run() {
t.m1();
}
}));
}
for(Thread thread : threads){
thread.start();
}
for(Thread thread : threads){
try {
thread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(t.count.intValue());
}
}
四、CountDownLatch
package cn.test.syn;
/**
* 门闩 - CountDownLatch
* 可以和锁混合使用，或替代锁的功能。
* 在门闩未完全开放之前等待。当门闩完全开放后执行。
* 避免锁的效率低下问题。
*/
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit; public class Test {
CountDownLatch latch = new CountDownLatch(5); void m1(){
try {
latch.await();// 等待门闩开放。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m1() method");
} void m2(){
for(int i = 0; i < 10; i++){
if(latch.getCount() != 0){
System.out.println("latch count : " + latch.getCount());
latch.countDown(); // 减门闩上的锁。
}
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("m2() method : " + i);
}
} public static void main(String[] args) {
final Test t = new Test();
new Thread(new Runnable() {
@Override
public void run() {
t.m1();
}
}).start(); new Thread(new Runnable() {
@Override
public void run() {
t.m2();
}
}).start();
}
}
Java并发编程基础——同步的更多相关文章
- Java并发编程基础
Java并发编程基础 1. 并发 1.1. 什么是并发? 并发是一种能并行运行多个程序或并行运行一个程序中多个部分的能力.如果程序中一个耗时的任务能以异步或并行的方式运行,那么整个程序的吞吐量和可交互 ...
- 并发-Java并发编程基础
Java并发编程基础 并发 在计算机科学中,并发是指将一个程序,算法划分为若干个逻辑组成部分,这些部分可以以任何顺序进行执行,但与最终顺序执行的结果一致.并发可以在多核操作系统上显著的提高程序运行速度 ...
- Java并发编程--基础进阶高级（完结）
Java并发编程--基础进阶高级完整笔记. 这都不知道是第几次刷狂神的JUC并发编程了,从第一次的迷茫到现在比较清晰,算是个大进步了,之前JUC笔记不见了,重新做一套笔记. 参考链接:https:// ...
- Java并发编程：同步容器
Java并发编程:同步容器 为了方便编写出线程安全的程序,Java里面提供了一些线程安全类和并发工具,比如:同步容器.并发容器.阻塞队列.Synchronizer(比如CountDownLatch). ...
- 【转】Java并发编程：同步容器
为了方便编写出线程安全的程序,Java里面提供了一些线程安全类和并发工具,比如:同步容器.并发容器.阻塞队列.Synchronizer(比如CountDownLatch).今天我们就来讨论下同步容器. ...
- 8、Java并发编程：同步容器
Java并发编程:同步容器 为了方便编写出线程安全的程序,Java里面提供了一些线程安全类和并发工具,比如:同步容器.并发容器.阻塞队列.Synchronizer(比如CountDownLatch). ...
- Java并发编程基础-线程安全问题及JMM(volatile)
什么情况下应该使用多线程 : 线程出现的目的是什么?解决进程中多任务的实时性问题?其实简单来说,也就是解决“阻塞”的问题,阻塞的意思就是程序运行到某个函数或过程后等待某些事件发生而暂时停止 CPU 占 ...
- java并发编程基础概念
本次内容主要讲进程和线程.CPU核心数和线程数.CPU时间片轮转机制.上下文切换,并行和并发的基本概念以及并发编程的好处和注意事项,为java并发编程打下扎实基础. 1.什么是进程和线程 1.1 进程 ...
- 多线程（一）java并发编程基础知识
线程的应用 如何应用多线程 在 Java 中,有多种方式来实现多线程.继承 Thread 类.实现 Runnable 接口.使用 ExecutorService.Callable.Future 实现带 ...
随机推荐
- BootStrap插件
站点引用 Bootstrap 插件的方式有两种: 单独引用:使用 Bootstrap 的个别的 *.js 文件.一些插件和 CSS 组件依赖于其他插件.如果您单独引用插件,请先确保弄清这些插件之间的依 ...
- Win10系统下安装Gradle-3.5
1. 下载 从官网https://gradle.org/releases/上下载3.5版本 2.解压 解压到D盘,路径是:D:\gradle-3.5 3.配置系统环境变量 首先依赖JAVA_HOME这 ...
- K3精益版给物料添加属性，并在BOM中新增字段引用该属性
1.给物料新增属性 打开“系统--基础资料--公共资料--核算项目管理”,然后双击物料,弹出核算项目类别-修改对话框.再点新增按钮: 输入你想新增字段的类型,长度,想要放置的位置. 相关属性里面选的是 ...
- .NET Core 微服务实例
关于微服务,MSDN给出了定义和架构图:https://docs.microsoft.com/zh-cn/azure/architecture/guide/architecture-styles/mi ...
- CentOS如何手动增加 删除swap区
SWAP是Linux中的虚拟内存,用于扩充物理内存不足而用来存储临时数据存在的.它类似于Windows中的虚拟内存.在Windows中,只可以使用文件来当作虚拟内存.而linux可以文件或者分区来当作 ...
- https及证书
本文试图以通俗易通的方式介绍Https的工作原理,不纠结具体的术语,不考证严格的流程.我相信弄懂了原理之后,到了具体操作和实现的时候,方向就不会错,然后条条大路通罗马.阅读文本需要提前大致了解对称加密 ...
- java上传文件常见几种方式
1.ServletFileUpload 表单提交中当提交数据类型是multipare/form-data类型的时候,如果我们用servlet去做处理的话,该http请求就会被servlet容器,包装成 ...
- 配置了yum本地源
测试机不能联网 所以不能直接安装软件 只能配置本地源 1. 在联网的电脑上下载与Linux内核版本相同的镜像 2. 把此安装镜像放在此Linux测试机上 比如放在家目录下 /home/ ...
- 描点的改进：运用chart画图。
主要是利用Chart画图: 通过选中一部分曲线进行图像的放大和缩小,最小值为1格. 先计算最大值和最小差值.然后赋值给AxisY.Minimum 和AxisY.Maximum.x轴初始显示数目:Axi ...
- CSS追加笔记
box-shadow 属性向框添加一个或多个阴影. 语法 box-shadow: h-shadow v-shadow blur spread color inset;注释:box-shadow 向框添 ...