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 实现带 ...
随机推荐
- SVN chechout 错误： xxx is not valid as filename in directory
转载:https://blog.csdn.net/ClementAD/article/details/47838989 意思就是Linux系统允许文件或文件夹的名字包含空格,而windows是不允许的 ...
- IDEA 上 Tigase8.0 源代码编译运行
Tigase交流群 :310790965 一些小伙伴们经常问Tigase8 check下来的源代码怎么跑起来,因为我不能及时一 一回答,所以还是写个博文来演示一下吧,一般针对新手而言,老手的话,就跳过 ...
- 3wwang的2019计划
1.探究osg类生物----系列(35天) 已完结 [置顶]探索未知种族之osg类生物[目录]www.3wwang.cn 2.osg中的设计模式---系列(15天) 正在创作... osg中抽象工厂 ...
- mactype配置
配合 Firefox 小小设置(改了好多配置,似乎主要是修改了渲染的核心?是叫这个么?把那个Siera?删掉了,就好了)后,效果极佳,我在原有配置的基础上,加大了字重,显示更粗,更明显. 这里是原配置 ...
- laraval migration 新增字段或者修改字段的方法
1.进入项目根目录执行artisan命令生成migration文件,可以指定--table和--path参数,会在对应目录下生成migration文件. php artisan make:migrat ...
- PCL-CMAKELIST书写格式
cmake_minimum_required(VERSION 2.6 FATAL_ERROR)//cmake最小版本 find_package(PCL 1.3 REQUIRED COMPONENTS ...
- XBee PRO 900HP远距离无线模块
XBee PRO S3B也称为XBee-900HP无线模块,它是一款工作在频段900~928MHz之间,基于FHSS跳频技术的远距离无线数传电台核心模块.常用型号如下: 类别 型号 开发套件 XKB9 ...
- git的使用方式总结
1.先用 git clone url 克隆下来项目 2.查看下载的项目里面有没有一个名字叫git的文件夹 3.用git branch查看当前所有的本地分支,绿色的代表当前所处的分支 4.若本地只有一个 ...
- eclipse遇到启动报an error has occurred see the log file错
错误: 修改eclipse安装目录下比如D:\eclipse\configuration\.settings\org.eclipse.ui.ide.prefs, 删除 RECENT_WORKSPACE ...
- vue学习_01
一.什么是VUE 渐进式的前端框架,MVVM(Model,view,viewmodel)模式,饿了么用的就是vue框架 二.VUE基本语法 1.引入vue: <script src=" ...