对象及变量的并发访问
- 2.1 Synchronized同步方法
- 2.2 synchronized同步语句块
- 2.2.1 synchronized方法的弊端
- 2.2.2 synchronized同步代码块的使用
- 2.2.3 用同步代码块解决同步方法的弊端
- 2.2.4 一半异步，一半同步
- 2.2.5 synchronized代码块间的同步性
- 2.2.6 验证同步synchronized(this)代码块是锁定当前对象的
- 2.2.7 将任意对象作为对象监视器
- 2.2.8 细化验证3个结论
- 2.2.9 静态同步synchronized方法与synchronized(class)代码块
- 2.2.10 数据类型String的常量池特性
- 2.2.11 同步synchronized方法无限等待与解决
- 2.2.12 对线程的死锁
- 2.2.13 内置类与静态内置类
- 2.2.14 内置类与同步：实验1
- 2.2.15 内置类与同步：实验2
- 2.2.16 锁对象的改变
- 2.3 volatile关键字
2.1 Synchronized同步方法
2.1.1 方法内的变量为线程安全
方法中的变量不存在线程安全问题，永远都是线程安全的。这是方法内部变量是私有造成的。（作用域）
2.1.2 实例变量非线程安全
如果多个线程共同访问1个对象中的示例变量，则有可能出现非线程安全的问题
2.1.3 多个对象多个锁
如果多个线程访问多个对象，则JVM会创建多个锁，就可能不能保证线程安全。
2.1.4 synchronized方法与锁对象
- 调用synchronized声明的方法一定是排队运行的。只有共享资源的读写访问才需要同步化.
- A线程先持有对象锁，B线程可以异步方法调用object对象中非同步的方法；
A线程先持有对象锁，B线程此时如果想要调用B线程中其他的同步方法，则需要等待A线程释放才行。
2.1.5 脏读
通过synchronized方法解决脏读的问题，具体方法看2.1.4。
2.1.6 synchronized锁重入
- 在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。即在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以得到锁的。
- 可重入锁也支持在父子类继承的环境中。子类可以通过“可重入锁”调用父类的同步方法。
2.1.7 出现异常，锁自动释放
当一个线程执行的代码出现异常时，其所持有的锁会自动释放。
2.1.8 同步不具有继承性
同步不可以继承。要在子类中加synchronized。
2.2 synchronized同步语句块
synchronized方法是对当前的对象进行枷锁，而synchronized代码块是对某一个对象进行枷锁。
2.2.1 synchronized方法的弊端
在业务场景上来说比如一个线程执行很长时间的任务，那么另外一个线程只能等待，对于高并发就显得力不从心。
2.2.2 synchronized同步代码块的使用
synchronized (this) {
System.out.println("A begin time=" + System.currentTimeMillis());
Thread.sleep(2000);
System.out.println("A end end=" + System.currentTimeMillis());
2.2.3 用同步代码块解决同步方法的弊端
当一个线程访问object的一个synchronized同步代码块时，另一个线程仍然可以访问该object对象中的非synchronized(this)同步代码块。
2.2.4 一半异步，一半同步
不在synchronized块中就是异步执行，在synchronized块中是同步执行。
2.2.5 synchronized代码块间的同步性
当一个线程访问object的一个synchronized同步代码块时，其他线程对同一个object中所有其他synchronized(this)同步代码块的访问将被阻塞。
2.2.6 验证同步synchronized(this)代码块是锁定当前对象的
2.2.7 将任意对象作为对象监视器
多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized(this)同步代码块时，调用的效果就是按顺序执行，也就是同步的，阻塞的。
这说明synchronized同步方法或synchronized(this)同步代码块分别有两种作用
- synchronized同步方法
- 对其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态
- 同一时间只有一个线程可以执行synchronized同步方法中的代码
- synchronized(this)同步代码块
- 对其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态
- 同一时间只有一个线程可以执行synchronized(this)同步代码块中的代码
- Java还支持对“任意对象”作为“对象监视器”来实现同步的功能。这个“任意对象”大多数是实例变量及方法的参数，使用synchronized(非this对象)
synchronized(非this对象)格式的作用只有1中：synchronized(非this对象x)同步代码块- 在多个线程持有“对象监视器”为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(非this对象x)同步代码块中的代码
- 当持有“对象监视器”为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(非this对象x)同步代码块中的代码。
锁非this对象的优点：如果在一个类中有很多个synchronized方法，这时虽然能实现同步，但会受到阻塞，所以 影响效率；但如果使用同步代码块锁非this对象，则synchronized(非this)代码块中的程序与同步方法是异步的，不与其他锁非this同步方法争抢this锁，则可以大大提高运行效率。
使用synchronized(非this对象x)同步代码块进行同步时，对象监视器必须是同一个对象。如果不是同一个对象监视器，运行的结果就是异步调用了，会交叉运行。如：
public void setUsernamePassword(String username,String password){
try{
String anyString = new String(); //监视器不是同一个对象
synchronized (anyString){
System.out.println("线程名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"进入同步");
usernameParam = username;
Thread.sleep(2000);
passwordParam = password;
System.out.println("线程名称为："+Thread.currentThread().getName()+"在"+System.currentTimeMillis()+"离开同步");
}
}catch(InterruptedException e){
e.printStackTrace();
}
}
持有不同的对象监视器是异步的效果。可能会出现脏读。解决方式是将对应的对象作为监视器。如synchronized(list)
2.2.8 细化验证3个结论
1）当多个对象同时执行synchronized（x）{}同步代码块是呈同步效果
public class MyObject {
}
public class Service {
public void testMethod1(MyObject object) {
synchronized (object) {
try {
System.out.println("testMethod1 get lock "+ System.currentTimeMillis()
+"threadname"+Thread.currentThread().getName());
Thread.sleep(2000);
System.out.println("testMethod1 release lock "+ System.currentTimeMillis()+
"threadname"+ Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ThreadA extends Thread{
private Service service;
private MyObject object;
public ThreadA(Service service, MyObject object) {
this.service = service;
this.object = object;
}
@Override
public void run() {
super.run();
service.testMethod1(object);
}
}
public class ThreadB extends Thread{
private Service service;
private MyObject object;
public ThreadB(Service service, MyObject object) {
this.service = service;
this.object = object;
}
@Override
public void run() {
super.run();
service.testMethod1(object);
}
}
public class Test {
public static void main(String[] args) {
MyObject myObject = new MyObject();
Service service = new Service();
ThreadA threadA = new ThreadA(service, myObject);
threadA.setName("a");
threadA.start();
ThreadB threadB = new ThreadB(service, myObject);
threadB.setName("b");
threadB.start();
}
}
testMethod1 get lock 1512737427975threadnamea
testMethod1 release lock 1512737429975threadnamea
testMethod1 get lock 1512737429975threadnameb
testMethod1 release lock 1512737431976threadnameb
如果使用不同的对象监视器会呈现异步效果
public class Test {
public static void main(String[] args) {
MyObject myObject1 = new MyObject();
MyObject myObject2 = new MyObject();
Service service = new Service();
ThreadA threadA = new ThreadA(service, myObject1);
threadA.setName("a");
threadA.start();
ThreadB threadB = new ThreadB(service, myObject2);
threadB.setName("b");
threadB.start();
}
}
testMethod1 get lock 1512737635943threadnamea
testMethod1 get lock 1512737635943threadnameb
testMethod1 release lock 1512737637955threadnamea
testMethod1 release lock 1512737637955threadnameb
2）当其他线程执行x对象中的synchronized同步方法呈现同步效果
public class MyObject {
synchronized public void speedPrintString(){
System.out.println("speedprint getLock time" + System.currentTimeMillis() + " threadname=" +
Thread.currentThread().getName());
System.out.println("___________________");
System.out.println("speedprint releaseLock time" + System.currentTimeMillis() + " threadname=" +
Thread.currentThread().getName());
}
}
public class Service {
public void testMethod1(MyObject object) {
synchronized (object) {
try {
System.out.println("testMethod1 get lock "+ System.currentTimeMillis()
+"threadname"+Thread.currentThread().getName());
Thread.sleep(2000);
System.out.println("testMethod1 release lock "+ System.currentTimeMillis()+
"threadname"+ Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ThreadA extends Thread{
private Service service;
private MyObject object;
public ThreadA(Service service, MyObject object) {
this.service = service;
this.object = object;
}
@Override
public void run() {
super.run();
service.testMethod1(object);
}
}
public class ThreadB extends Thread{
private MyObject object;
public ThreadB(Service service, MyObject object) {
this.object = object;
}
@Override
public void run() {
super.run();
object.speedPrintString();
}
}
public class Test {
public static void main(String[] args) {
MyObject myObject = new MyObject();
Service service = new Service();
ThreadA threadA = new ThreadA(service, myObject);
threadA.setName("a");
threadA.start();
ThreadB threadB = new ThreadB(service, myObject);
threadB.setName("b");
threadB.start();
}
}
testMethod1 get lock 1512737929269threadnamea
testMethod1 release lock 1512737931269threadnamea
speedprint getLock time1512737931269 threadname=b
___________________
speedprint releaseLock time1512737931269 threadname=b
3）当其他线程执行x对象方法里面的synchronized（this）代码块时呈同步效果
public class MyObject {
public void speedPrintString(){
synchronized (this) {
System.out.println("speedprint getLock time" + System.currentTimeMillis() + " threadname=" +
Thread.currentThread().getName());
System.out.println("___________________");
System.out.println("speedprint releaseLock time" + System.currentTimeMillis() + " threadname=" +
Thread.currentThread().getName());
}
}
}
testMethod1 get lock 1512738280991threadnamea
testMethod1 release lock 1512738283002threadnamea
speedprint getLock time1512738283002 threadname=b
___________________
speedprint releaseLock time1512738283002 threadname=b
注：如果其他线程调用不加synchronized关键字的方法时，还是异步调用
2.2.9 静态同步synchronized方法与synchronized(class)代码块
synchronized public static void show() {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
对象锁和类锁同时使用会呈现异步效果。类锁对类的所有对象实例起作用。
synchronized(class)代码块
public class Service {
public static void printA() {
synchronized (Service.class) {
try {
System.out.println("线程名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "进入printA");
Thread.sleep(3000);
System.out.println("线程名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "离开printA");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void printB() {
synchronized (Service.class) {
System.out.println("线程名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "进入printB");
System.out.println("线程名称为：" + Thread.currentThread().getName()
+ "在" + System.currentTimeMillis() + "离开printB");
}
}
}
类锁和对象锁两者互不影响。类锁和对象锁是两个不一样的锁，控制着不同的区域，它们是互不干扰的。同样，线程获得对象锁的同时，也可以获得该类锁，即同时获得两个锁，这是允许的。
若类对象被lock，则类对象的所有同步方法全被lock；
若实例对象被lock，则该实例对象的所有同步方法全被lock
2.2.10 数据类型String的常量池特性
多数情况下，同步synchronized代码块都不使用String作为锁对象，因为可能发生两个String相同，那么另一个线程永远不会得到执行。
2.2.11 同步synchronized方法无限等待与解决
使用同步块可以解决。
2.2.12 对线程的死锁
使用JDK自带的工具来监测是否有死锁的现象：
（1）进CMD，再进入JDK的安装文件夹中的bin目录，执行jps命令
（2）得到运行的线程Run的id，在执行jstack命令，即jstack -l id号
在程序设计时要避免双方互相持有对方的锁的情况。有可能出现死锁。
2.2.13 内置类与静态内置类
- 内置类
类中还有一个类。若PublicClass.java类和Run.java类不在同一个包里，则需要将PrivateClass内置声明成public公开的。
实例化内置类PrivateClass privateClass = publicClass.new PrivateClass(); - 静态内置类
语法为为：
实例化方法static class PrivateClass{ }PrivateClass privateClass = new PrivateClass();
2.2.14 内置类与同步：实验1
在内置类中有两个同步方法，但使用的却是不同的锁，结果是异步的。
2.2.15 内置类与同步：实验2
同步代码块synchronized(class2)对class2上锁后，其他线程只能以同步的方法调用class2中的静态同步方法。
2.2.16 锁对象的改变
只要对象不变，即使对象的属性被改变，运行的结果还是同步。
2.3 volatile关键字
2.3.1 关键字volatile与死循环
关键字volatile的主要作用是使变量在多个线程间可见。
2.3.2 解决同步死循环
关键字volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据中取得变量的值。
2.3.3 解决异步死循环
public class RunThread extends Thread{
private boolean isRunning = true;
public boolean isRunning() {
return isRunning;
}
public void setRunning(boolean isRunning) {
this.isRunning = isRunning;
}
@Override
public void run() {
System.out.println("进入run方法");
while(isRunning == true) {
}
System.out.println("线程被停止了");
}
}
public class Run {
public static void main(String[] args) {
try {
RunThread runThread = new RunThread();
runThread.start();
Thread.sleep(1000);
runThread.setRunning(false);
System.out.println("已经赋值false");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
进入run方法
已经赋值false
在启动线程时，变量的值是存在于公共堆栈及线程的私有堆栈中。在JVM被设置为-server 模式时为了线程运行的效率，线程一直在私有堆栈中取变量的值，即使有其他线程将变量的值进行了修改，更新的却是公共堆栈中的变量值，私有堆栈中的值不会变，这就导致线程运行存在问题。内存关系如图：
public class RunThread extends Thread{
volatile private boolean isRunning = true;
public boolean isRunning() {
return isRunning;
}
public void setRunning(boolean isRunning) {
this.isRunning = isRunning;
}
@Override
public void run() {
System.out.println("进入run方法");
while(isRunning == true) {
}
System.out.println("线程被停止了");
}
}
进入run方法
已经赋值false
线程被停止了
使用volcatile关键字增加了实例变量在多个线程之间的可见性，但volatile关键字最致命的缺点是不支持原子性。
下面是和synchronized关键字的比较
1）关键字volatile是线程同步的轻量级实现，所以volatile性能比synchronized要好，并且volatile只能修饰变量，而synchronized可以修饰方法和代码块，随着JDK新版本的发布，synchronized关键字在执行效率上得到很大的提高，在开发中使用synchronized还是很常见的。
2）多线程访问volatile不会发生堵塞，而synchronized会阻塞。
3）volatile能保证数据的可见性，不能保证原子性，而synchronized可以保证可见性和原子性，因为他会将私有内存和公共内存中的数据做同步。
4）volatile解决的是变量在多个线程之间的可见性，而synchronized关键字解决的是多个线程之间访问资源的同步性。
2.3.4 volatile非原子的特性
volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到内存的。即volatile本身无法保证原子性，对多个线程访问同一个实例变量还是需要加锁同步。
2.3.5 使用原子类进行i++操作
除了在i++操作时使用synchronized关键字实现同步外，还可以使用AtomicInteger原子类进行实现。
原子操作时不可分割的整体，没有其他线程能够中断或检查正在原子操作的变量，一个原子类型就是一个原子操作的可用类型，他可以在没有锁的情况下，做到线程安全。
import java.util.concurrent.atomic.AtomicInteger;
/**
* Created by edison on 2017/12/9.
*/
public class AddCountThread extends Thread{
private AtomicInteger count = new AtomicInteger(0);
@Override
public void run() {
super.run();
for (int i = 0; i < 10000; i++) {
System.out.println(count.incrementAndGet());
}
}
}
public class Run {
public static void main(String[] args) {
AddCountThread addCountThread = new AddCountThread();
Thread t1 = new Thread(addCountThread);
t1.start();
Thread t2 = new Thread(addCountThread);
t2.start();
Thread t3 = new Thread(addCountThread);
t3.start();
Thread t4 = new Thread(addCountThread);
t4.start();
Thread t5 = new Thread(addCountThread);
t5.start();
}
}
2.3.6 原子类也并不完全安全
方法与方法之间不是原子的，也会出现线程不安全的情况。解决方法：使用synchronized。
2.3.7 synchronized代码块有volatile同步的功能
关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或者某一个代码块。他包含了两个特性，互斥性和可见性，同步synchronized不仅可以解决一个线程看到的对象处于不一致的状态，还可以保证进入同步方法或者同步代码块的每个线程都看到由同一个锁保护之前的修改效果。
public class Service {
private boolean isContinueRun = true;
public void runMethod() {
String anything =new String();
while(isContinueRun == true) {
synchronized (anything) {
}
}
System.out.println("停下来了");
}
public void stopMethod() {
isContinueRun = false;
}
}
public class ThreadA extends Thread{
private Service service;
public ThreadA (Service service) {
this.service = service;
}
@Override
public void run() {
super.run();
service.runMethod();
}
}
public class ThreadB extends Thread{
private Service service;
public ThreadB (Service service) {
this.service = service;
}
@Override
public void run() {
super.run();
service.stopMethod();
}
}
public class Run {
public static void main(String[] args) {
try {
Service service = new Service();
ThreadA threadA = new ThreadA(service);
threadA.start();
Thread.sleep(2000);
ThreadB threadB = new ThreadB(service);
threadB.start();
System.out.println("已经发起停止的命令");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
已经发起停止的命令
停下来了
1414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
