关键字 synchronized可用来保障原子性、可见性和有序性方法内的变量为线程安全
非线程安全问题存在于实例变量中,对于方 法内部的私有变量,则不存在非线程安全问题,结果是 “ 线程安全 ” 的。下面的示例用于演示在方法内部声明一个变量时,是不存在非线程安全问题的 HasSelfPrivateNum.java文件代 码
package chapter2.test2_1.test2_1_1;
public class HasSelfPrivateNum {
public void addI(String username) {
try {
int num = 0;
if (username.equals("a")) {
num = 100;
System.out.println("a set over!");
Thread.sleep(2000);
} else {
num = 200;
System.out.println("b set over!");
}
System.out.println(username + " num=" + num);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
文件ThreadA.java代码
package chapter2.test2_1.test2_1_1;
public class ThreadA extends Thread {
private HasSelfPrivateNum numRef;
public ThreadA(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
}
@Override
public void run() {
super.run();
numRef.addI("a");
}
}
文件ThreadB.java代码
package chapter2.test2_1.test2_1_1;
public class ThreadB extends Thread {
private HasSelfPrivateNum numRef;
public ThreadB(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
}
@Override
public void run() {
super.run();
numRef.addI("b");
}
}
文件Run.java代码
package chapter2.test2_1.test2_1_1;
import java.util.Iterator;
import java.util.Map;
public class Run {
public static void main(String[] args) {
HasSelfPrivateNum numRef = new HasSelfPrivateNum();
ThreadA athread = new ThreadA(numRef);
athread.start();
ThreadB bthread = new ThreadB(numRef);
bthread.start();
//打印所有堆栈信息
printAllStackTraces();
}
private static void printAllStackTraces() {
// Map allStackTraces = Thread.getAllStackTraces();
Map map = Thread.currentThread().getAllStackTraces();
if (map != null && map.size() != 0) {
Iterator keyIterator = map.keySet().iterator();
while (keyIterator.hasNext()) {
Thread eachThread = (Thread) keyIterator.next();
StackTraceElement[] array = map.get(eachThread);
System.out.println("------每个线程的基本信息");
System.out.println(" 线程名称:" + eachThread.getName());
System.out.println(" StackTraceElement[].length=" + array.length);
System.out.println(" 线程的状态:" + eachThread.getState());
if (array.length != 0) {
System.out.println(" 输出StackTraceElement[]数组具体信息:");
for (int i = 0; i < array.length; i++) {
StackTraceElement eachElement = array[i];
System.out.println(
" " + eachElement.getClassName()
+ " " + eachElement.getMethodName()
+ " " + eachElement.getFileName()
+ " " + eachElement.getLineNumber());
}
} else {
System.out.println(" 没有StackTraceElement[]信息,因为线程" + eachThread.getName() + "中的stackTraceElement[].length==" + array.length);
}
System.out.println();
System.out.println();
}
}
}
}
输出结果
方法中的变量不存在非线程安全问题,永远 都是线程安全的,这是因为方法内部的变量具有私有特性。 实例变量非线程安全问题与解决方案a set over!
b set over!
b num=200
------每个线程的基本信息
线程名称:Monitor Ctrl-Break
StackTraceElement[].length=24
线程的状态:RUNNABLE
输出StackTraceElement[]数组具体信息:
java.util.Properties load0 Properties.java 345
java.util.Properties load Properties.java 341
sun.net.NetProperties loadDefaultProperties NetProperties.java 70
sun.net.NetProperties access$000 NetProperties.java 41
sun.net.NetProperties$1 run NetProperties.java 47
sun.net.NetProperties$1 run NetProperties.java 45
java.security.AccessController doPrivileged AccessController.java -2
sun.net.NetPropertiesNetProperties.java 44
sun.net.spi.DefaultProxySelector$1 run DefaultProxySelector.java 95
sun.net.spi.DefaultProxySelector$1 run DefaultProxySelector.java 93
java.security.AccessController doPrivileged AccessController.java -2
sun.net.spi.DefaultProxySelectorDefaultProxySelector.java 92
java.lang.Class forName0 Class.java -2
java.lang.Class forName Class.java 264
java.net.ProxySelectorProxySelector.java 72
java.net.SocksSocketImpl$3 run SocksSocketImpl.java 358
java.net.SocksSocketImpl$3 run SocksSocketImpl.java 356
java.security.AccessController doPrivileged AccessController.java -2
java.net.SocksSocketImpl connect SocksSocketImpl.java 355
java.net.Socket connect Socket.java 606
java.net.Socket connect Socket.java 555
java.net.SocketSocket.java 451
java.net.SocketSocket.java 228
com.intellij.rt.execution.application.AppMainV2$1 run AppMainV2.java 43
------每个线程的基本信息
线程名称:Signal Dispatcher
StackTraceElement[].length=0
线程的状态:RUNNABLE
没有StackTraceElement[]信息,因为线程Signal Dispatcher中的stackTraceElement[].length==0
------每个线程的基本信息
线程名称:main
StackTraceElement[].length=3
线程的状态:RUNNABLE
输出StackTraceElement[]数组具体信息:
java.lang.Thread dumpThreads Thread.java -2
java.lang.Thread getAllStackTraces Thread.java 1610
chapter2.test2_1.test2_1_1.Run main Run.java 15
------每个线程的基本信息
线程名称:Thread-0
StackTraceElement[].length=3
线程的状态:TIMED_WAITING
输出StackTraceElement[]数组具体信息:
java.lang.Thread sleep Thread.java -2
chapter2.test2_1.test2_1_1.HasSelfPrivateNum addI HasSelfPrivateNum.java 10
chapter2.test2_1.test2_1_1.ThreadA run ThreadA.java 14
------每个线程的基本信息
线程名称:Thread-1
StackTraceElement[].length=2
线程的状态:TERMINATED
输出StackTraceElement[]数组具体信息:
chapter2.test2_1.test2_1_1.HasSelfPrivateNum addI HasSelfPrivateNum.java 13
chapter2.test2_1.test2_1_1.ThreadB run ThreadB.java 14
------每个线程的基本信息
线程名称:Reference Handler
StackTraceElement[].length=4
线程的状态:WAITING
输出StackTraceElement[]数组具体信息:
java.lang.Object wait Object.java -2
java.lang.Object wait Object.java 502
java.lang.ref.Reference tryHandlePending Reference.java 191
java.lang.ref.Reference$ReferenceHandler run Reference.java 153
------每个线程的基本信息
线程名称:Attach Listener
StackTraceElement[].length=0
线程的状态:RUNNABLE
没有StackTraceElement[]信息,因为线程Attach Listener中的stackTraceElement[].length==0
------每个线程的基本信息
线程名称:Finalizer
StackTraceElement[].length=4
线程的状态:WAITING
输出StackTraceElement[]数组具体信息:
java.lang.Object wait Object.java -2
java.lang.ref.ReferenceQueue remove ReferenceQueue.java 144
java.lang.ref.ReferenceQueue remove ReferenceQueue.java 165
java.lang.ref.Finalizer$FinalizerThread run Finalizer.java 216
a num=100
如果多个线程共同访问一个对象中的实例变 量,则有可能出现非线程安全问题。 用线程访问的对象中如果有多个实例变量, 则运行的结果有可能出现交叉的情况。 如果对象仅有一个实例变量,则有可能出现 覆盖的情况。HasSelfPrivateNum.java文件代码
package chapter2.test2_1.test2_1_2;
public class HasSelfPrivateNum {
private int num = 0;
public void addI(String username) {
try {
if (username.equals("a")) {
num = 100;
System.out.println("a set over!");
Thread.sleep(2000);
} else {
num = 200;
System.out.println("b set over!");
}
System.out.println(username + " num=" + num);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
文件ThreadA.java代码
同上,略
文件ThreadB.java代码 同上,略 文件Run.java代码 同上,略 程序运行结果b set over!
a set over!
------每个线程的基本信息
线程名称:Monitor Ctrl-Break
StackTraceElement[].length=21
b num=200
线程的状态:RUNNABLE
输出StackTraceElement[]数组具体信息:
java.util.HashtableHashtable.java 191
java.util.HashtableHashtable.java 212
java.util.PropertiesProperties.java 148
java.util.PropertiesProperties.java 140
sun.net.NetPropertiesNetProperties.java 42
sun.net.spi.DefaultProxySelector$1 run DefaultProxySelector.java 95
sun.net.spi.DefaultProxySelector$1 run DefaultProxySelector.java 93
java.security.AccessController doPrivileged AccessController.java -2
sun.net.spi.DefaultProxySelectorDefaultProxySelector.java 92
java.lang.Class forName0 Class.java -2
java.lang.Class forName Class.java 264
java.net.ProxySelectorProxySelector.java 72
java.net.SocksSocketImpl$3 run SocksSocketImpl.java 358
java.net.SocksSocketImpl$3 run SocksSocketImpl.java 356
java.security.AccessController doPrivileged AccessController.java -2
java.net.SocksSocketImpl connect SocksSocketImpl.java 355
java.net.Socket connect Socket.java 606
java.net.Socket connect Socket.java 555
java.net.SocketSocket.java 451
java.net.SocketSocket.java 228
com.intellij.rt.execution.application.AppMainV2$1 run AppMainV2.java 43
------每个线程的基本信息
线程名称:Signal Dispatcher
StackTraceElement[].length=0
线程的状态:RUNNABLE
没有StackTraceElement[]信息,因为线程Signal Dispatcher中的stackTraceElement[].length==0
------每个线程的基本信息
线程名称:main
StackTraceElement[].length=4
线程的状态:RUNNABLE
输出StackTraceElement[]数组具体信息:
java.lang.Thread dumpThreads Thread.java -2
java.lang.Thread getAllStackTraces Thread.java 1610
chapter2.test2_1.test2_1_2.Run printAllStackTraces Run.java 19
chapter2.test2_1.test2_1_2.Run main Run.java 14
------每个线程的基本信息
线程名称:Thread-0
StackTraceElement[].length=0
线程的状态:TIMED_WAITING
没有StackTraceElement[]信息,因为线程Thread-0中的stackTraceElement[].length==0
------每个线程的基本信息
线程名称:Thread-1
StackTraceElement[].length=0
线程的状态:TERMINATED
没有StackTraceElement[]信息,因为线程Thread-1中的stackTraceElement[].length==0
------每个线程的基本信息
线程名称:Reference Handler
StackTraceElement[].length=4
线程的状态:WAITING
输出StackTraceElement[]数组具体信息:
java.lang.Object wait Object.java -2
java.lang.Object wait Object.java 502
java.lang.ref.Reference tryHandlePending Reference.java 191
java.lang.ref.Reference$ReferenceHandler run Reference.java 153
------每个线程的基本信息
线程名称:Attach Listener
StackTraceElement[].length=0
线程的状态:RUNNABLE
没有StackTraceElement[]信息,因为线程Attach Listener中的stackTraceElement[].length==0
------每个线程的基本信息
线程名称:Finalizer
StackTraceElement[].length=4
线程的状态:WAITING
输出StackTraceElement[]数组具体信息:
java.lang.Object wait Object.java -2
java.lang.ref.ReferenceQueue remove ReferenceQueue.java 144
java.lang.ref.ReferenceQueue remove ReferenceQueue.java 165
java.lang.ref.Finalizer$FinalizerThread run Finalizer.java 216
a num=200
上面的实验是两个线程同时访问同一个业务 对象中的一个没有同步的方法,如果两个线程同时操作业务对象中的实例变量,则有可能出现非 线程安全问题,此示例的知识点在前面已经介绍 过,只需要在 public void addI ( String username)方法前加关键字 synchronized 即可,更改后的代码 如下
package chapter2.test2_1.test2_1_3;
public class HasSelfPrivateNum {
private int num = 0;
synchronized public void addI(String username) {
try {
if (username.equals("a")) {
num = 100;
System.out.println("a set over!");
Thread.sleep(2000);
} else {
num = 200;
System.out.println("b set over!");
}
System.out.println(username + " num=" + num);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
输出结果如下
a set over!
------每个线程的基本信息
线程名称:Monitor Ctrl-Break
StackTraceElement[].length=7
线程的状态:RUNNABLE
输出StackTraceElement[]数组具体信息:
sun.net.spi.DefaultProxySelector select DefaultProxySelector.java 192
java.net.SocksSocketImpl connect SocksSocketImpl.java 386
java.net.Socket connect Socket.java 606
java.net.Socket connect Socket.java 555
java.net.SocketSocket.java 451
java.net.SocketSocket.java 228
com.intellij.rt.execution.application.AppMainV2$1 run AppMainV2.java 43
------每个线程的基本信息
线程名称:Signal Dispatcher
StackTraceElement[].length=0
线程的状态:RUNNABLE
没有StackTraceElement[]信息,因为线程Signal Dispatcher中的stackTraceElement[].length==0
------每个线程的基本信息
线程名称:main
StackTraceElement[].length=4
线程的状态:RUNNABLE
输出StackTraceElement[]数组具体信息:
java.lang.Thread dumpThreads Thread.java -2
java.lang.Thread getAllStackTraces Thread.java 1610
chapter2.test2_1.test2_1_3.Run printAllStackTraces Run.java 20
chapter2.test2_1.test2_1_3.Run main Run.java 15
------每个线程的基本信息
线程名称:Thread-0
StackTraceElement[].length=3
线程的状态:TIMED_WAITING
输出StackTraceElement[]数组具体信息:
java.lang.Thread sleep Thread.java -2
chapter2.test2_1.test2_1_3.HasSelfPrivateNum addI HasSelfPrivateNum.java 11
chapter2.test2_1.test2_1_3.ThreadA run ThreadA.java 15
------每个线程的基本信息
线程名称:Thread-1
StackTraceElement[].length=2
线程的状态:BLOCKED
输出StackTraceElement[]数组具体信息:
chapter2.test2_1.test2_1_3.HasSelfPrivateNum addI HasSelfPrivateNum.java 8
chapter2.test2_1.test2_1_3.ThreadB run ThreadB.java 15
------每个线程的基本信息
线程名称:Reference Handler
StackTraceElement[].length=4
线程的状态:WAITING
输出StackTraceElement[]数组具体信息:
java.lang.Object wait Object.java -2
java.lang.Object wait Object.java 502
java.lang.ref.Reference tryHandlePending Reference.java 191
java.lang.ref.Reference$ReferenceHandler run Reference.java 153
------每个线程的基本信息
线程名称:Attach Listener
StackTraceElement[].length=0
线程的状态:RUNNABLE
没有StackTraceElement[]信息,因为线程Attach Listener中的stackTraceElement[].length==0
------每个线程的基本信息
线程名称:Finalizer
StackTraceElement[].length=4
线程的状态:WAITING
输出StackTraceElement[]数组具体信息:
java.lang.Object wait Object.java -2
java.lang.ref.ReferenceQueue remove ReferenceQueue.java 144
java.lang.ref.ReferenceQueue remove ReferenceQueue.java 165
java.lang.ref.Finalizer$FinalizerThread run Finalizer.java 216
a num=100
b set over!
b num=200Process finished with exit code 0
同步了,线程安全了
结论两个线程同时访问同一个对象中的同 步方法时一定是线程安全的。在本实验中,由于 线程是同步访问的,并且 a线程先执行,所以先输出 a ,然后输出 b ,但是完全有可能 b线程先运行, 那么就先输出 b ,后输出 a,不管哪个线程先运行,这个线程进入用 synchronized声明的方法时就 上锁,方法执行完成后自动解锁,之后下一个线程才会进入用 synchronized声明的方法里,不解锁 其他线程执行不了用 synchronized 声明的方法。同步synchronized在字节码指令中的原理
在方法中使用 synchronized关键字实现同步的原因是使用了 flag 标记 ACC_SYN-CHRONIZED,当调用方法时,调用指令会检查方法的 ACC_SYNCHRONIZED 访问标志 是否设置,如果设置了,执行线程先持有同步锁,然后执行方法,最后在方法完成时释放锁。测试代码
package chapter2.test2_1.test2_1_4;
public class Test {
synchronized public static void testMethod() {
}
public static void main(String[] args) throws InterruptedException {
testMethod();
}
}
在 cmd 中使用 javap 命令将 class文件转成字节码指令, 参数 -v 用于输出附加信息,参数 -c用于对代码进行反汇 编。使用 javap.exe 命令如下:
javap -c -v Test.class生成这个 class文件对应的字节码指令,指令的代码如下
E:idea_workspacestudyspringboot_elementuispring-boot-vue-elementnodeJava_multi-thread_programmingtargetclasseschapter2test2_1test2_1_4>javap -c -v Test.class Classfile /E:/idea_workspace/study/springboot_elementui/spring-boot-vue-element/node/Java_multi-thread_programming/target/classes/chapter2/test2_1/test2_1_4/Test.class Last modified 2022-6-7; size 537 bytes MD5 checksum 63dc4093d7e25ce8bc45f364ec3755cb Compiled from "Test.java" public class chapter2.test2_1.test2_1_4.Test minor version: 0 major version: 52 flags: ACC_PUBLIC, ACC_SUPER Constant pool: #1 = Methodref #4.#21 // java/lang/Object."":()V #2 = Methodref #3.#22 // chapter2/test2_1/test2_1_4/Test.testMethod:()V #3 = Class #23 // chapter2/test2_1/test2_1_4/Test #4 = Class #24 // java/lang/Object #5 = Utf8 #6 = Utf8 ()V #7 = Utf8 Code #8 = Utf8 LineNumberTable #9 = Utf8 LocalVariableTable #10 = Utf8 this #11 = Utf8 Lchapter2/test2_1/test2_1_4/Test; #12 = Utf8 testMethod #13 = Utf8 main #14 = Utf8 ([Ljava/lang/String;)V #15 = Utf8 args #16 = Utf8 [Ljava/lang/String; #17 = Utf8 Exceptions #18 = Class #25 // java/lang/InterruptedException #19 = Utf8 SourceFile #20 = Utf8 Test.java #21 = NameAndType #5:#6 // " ":()V #22 = NameAndType #12:#6 // testMethod:()V #23 = Utf8 chapter2/test2_1/test2_1_4/Test #24 = Utf8 java/lang/Object #25 = Utf8 java/lang/InterruptedException { public chapter2.test2_1.test2_1_4.Test(); descriptor: ()V flags: ACC_PUBLIC Code: stack=1, locals=1, args_size=1 0: aload_0 1: invokespecial #1 // Method java/lang/Object." ":()V 4: return LineNumberTable: line 3: 0 LocalVariableTable: Start Length Slot Name Signature 0 5 0 this Lchapter2/test2_1/test2_1_4/Test; public static synchronized void testMethod(); descriptor: ()V flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED Code: stack=0, locals=0, args_size=0 0: return LineNumberTable: line 5: 0 public static void main(java.lang.String[]) throws java.lang.InterruptedException; descriptor: ([Ljava/lang/String;)V flags: ACC_PUBLIC, ACC_STATIC Code: stack=0, locals=1, args_size=1 0: invokestatic #2 // Method testMethod:()V 3: return LineNumberTable: line 8: 0 line 9: 3 LocalVariableTable: Start Length Slot Name Signature 0 4 0 args [Ljava/lang/String; Exceptions: throws java.lang.InterruptedException } SourceFile: "Test.java"
在反编译的字节码指令中,对public synchronized void myMethod() 方法使用了 flag 标记 ACC_SYNCHRONIZED,说明此方法是同步的。
如果使用 synchronized 代码块,则使用 monitorenter和 monitorexit 指令进行同步处理,测试代码如下:
package chapter2.test2_1.test2_1_4;
public class Test2 {
public void myMethod() {
synchronized (this) {
int age = 100;
}
}
public static void main(String[] args) throws InterruptedException {
Test2 test = new Test2();
test.myMethod();
}
}
在
cmd
中使用命令:
javap -c -v Test2.class生成这个 class文件对应的字节码指令,指令代码 如下:
E:idea_workspacestudyspringboot_elementuispring-boot-vue-elementnodeJava_multi-thread_programmingtargetclasseschapter2test2_1test2_1_4>javap -c -v Test2.class Classfile /E:/idea_workspace/study/springboot_elementui/spring-boot-vue-element/node/Java_multi-thread_programming/target/classes/chapter2/test2_1/test2_1_4/Test2.class Last modified 2022-6-7; size 710 bytes MD5 checksum 15fd93ff72f2118c0bac6f160e8ee543 Compiled from "Test2.java" public class chapter2.test2_1.test2_1_4.Test2 minor version: 0 major version: 52 flags: ACC_PUBLIC, ACC_SUPER Constant pool: #1 = Methodref #5.#27 // java/lang/Object."字节码中使用 monitorenter和 monitorexit指令进行同步 处理。 经过前面的测试,我们可以明白同步与异步 的区别。":()V #2 = Class #28 // chapter2/test2_1/test2_1_4/Test2 #3 = Methodref #2.#27 // chapter2/test2_1/test2_1_4/Test2." ":()V #4 = Methodref #2.#29 // chapter2/test2_1/test2_1_4/Test2.myMethod:()V #5 = Class #30 // java/lang/Object #6 = Utf8 #7 = Utf8 ()V #8 = Utf8 Code #9 = Utf8 LineNumberTable #10 = Utf8 LocalVariableTable #11 = Utf8 this #12 = Utf8 Lchapter2/test2_1/test2_1_4/Test2; #13 = Utf8 myMethod #14 = Utf8 StackMapTable #15 = Class #28 // chapter2/test2_1/test2_1_4/Test2 #16 = Class #30 // java/lang/Object #17 = Class #31 // java/lang/Throwable #18 = Utf8 main #19 = Utf8 ([Ljava/lang/String;)V #20 = Utf8 args #21 = Utf8 [Ljava/lang/String; #22 = Utf8 test #23 = Utf8 Exceptions #24 = Class #32 // java/lang/InterruptedException #25 = Utf8 SourceFile #26 = Utf8 Test2.java #27 = NameAndType #6:#7 // " ":()V #28 = Utf8 chapter2/test2_1/test2_1_4/Test2 #29 = NameAndType #13:#7 // myMethod:()V #30 = Utf8 java/lang/Object #31 = Utf8 java/lang/Throwable #32 = Utf8 java/lang/InterruptedException { public chapter2.test2_1.test2_1_4.Test2(); descriptor: ()V flags: ACC_PUBLIC Code: stack=1, locals=1, args_size=1 0: aload_0 1: invokespecial #1 // Method java/lang/Object." ":()V 4: return LineNumberTable: line 3: 0 LocalVariableTable: Start Length Slot Name Signature 0 5 0 this Lchapter2/test2_1/test2_1_4/Test2; public void myMethod(); descriptor: ()V flags: ACC_PUBLIC Code: stack=2, locals=4, args_size=1 0: aload_0 1: dup 2: astore_1 3: monitorenter 4: bipush 100 6: istore_2 7: aload_1 8: monitorexit 9: goto 17 12: astore_3 13: aload_1 14: monitorexit 15: aload_3 16: athrow 17: return Exception table: from to target type 4 9 12 any 12 15 12 any LineNumberTable: line 5: 0 line 6: 4 line 7: 7 line 8: 17 LocalVariableTable: Start Length Slot Name Signature 0 18 0 this Lchapter2/test2_1/test2_1_4/Test2; StackMapTable: number_of_entries = 2 frame_type = 255 offset_delta = 12 locals = [ class chapter2/test2_1/test2_1_4/Test2, class java/lang/Object ] stack = [ class java/lang/Throwable ] frame_type = 250 offset_delta = 4 public static void main(java.lang.String[]) throws java.lang.InterruptedException; descriptor: ([Ljava/lang/String;)V flags: ACC_PUBLIC, ACC_STATIC Code: stack=2, locals=2, args_size=1 0: new #2 // class chapter2/test2_1/test2_1_4/Test2 3: dup 4: invokespecial #3 // Method " ":()V 7: astore_1 8: aload_1 9: invokevirtual #4 // Method myMethod:()V 12: return LineNumberTable: line 11: 0 line 12: 8 line 13: 12 LocalVariableTable: Start Length Slot Name Signature 0 13 0 args [Ljava/lang/String; 8 5 1 test Lchapter2/test2_1/test2_1_4/Test2; Exceptions: throws java.lang.InterruptedException } SourceFile: "Test2.java" E:idea_workspacestudyspringboot_elementuispring-boot-vue-elementnodeJava_multi-thread_programmingtargetclasseschapter2test2_1test2_1_4>
同步:按顺序执行 A 和 B 这两个业务,就是同步。 异步:执行 A 业务的时候, B业务也在同时执行,就 是异步。多个对象多个锁 创建HasSelfPrivateNum.java 类
package chapter2.test2_1.test2_1_4.test1;
public class HasSelfPrivateNum {
private int num = 0;
synchronized public void addI(String username) {
try {
if (username.equals("a")) {
num = 100;
System.out.println("a set over!");
Thread.sleep(2000);
} else {
num = 200;
System.out.println("b set over!");
}
System.out.println(username + " num=" + num);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
创建线程ThreadA.java和ThreadB.java代码
package chapter2.test2_1.test2_1_4.test1;
public class ThreadA extends Thread {
private HasSelfPrivateNum numRef;
public ThreadA(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
}
@Override
public void run() {
super.run();
numRef.addI("a");
}
}
package chapter2.test2_1.test2_1_4.test1;
public class ThreadB extends Thread {
private HasSelfPrivateNum numRef;
public ThreadB(HasSelfPrivateNum numRef) {
super();
this.numRef = numRef;
}
@Override
public void run() {
super.run();
numRef.addI("b");
}
}
类Run.java代码
package chapter2.test2_1.test2_1_4.test1;
public class Run {
public static void main(String[] args) {
HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();
ThreadA athread = new ThreadA(numRef1);
athread.start();
ThreadB bthread = new ThreadB(numRef2);
bthread.start();
}
}
程序运行结果
本示例创建了两个业务对象,在系统中产生 两个锁,线程和业务对象属于一对一的关系,每 个线程执行自己所属业务对象中的同步方法,不 存在争抢关系,所以运行结果是异步的,另外, 在这种情况下, synchronized可以不需要,因为不 会出现非线程安全问题。
只有多个线程执行相同的业务对象中的同步 方法时,线程和业务对象属于多对一的关系,为了避免出现非线程安全问题,所以使用了 synchronized 。
从上面的程序运行结果来看,虽然在 HasSelfPrivateNum.java 中使用了 synchronized 关键 字,但输出顺序不是同步的,而是交叉的,为什 么是这样的结果呢?关键字synchronized取得的锁 都是对象锁,而不是把一段代码或方法当作锁, 所以在上面的示例中,哪个线程先执行带 synchronized关键字的方法,哪个线程就持有该方 法所属对象的锁Lock,那么其他线程只能处于等 待状态,前提是多个线程访问的是同一个对象。 但如果多个线程访问多个对象,也就是每个线程 访问自己所属的业务对象(上面的示例就是这种 情况),则JVM会创建多个锁,不存在锁争抢的 情况。另外,更具体地讲,由于本示例创建了两 个业务对象,所以产生两份实例变量,每个线程 访问自己的实例变量,所以加不加 synchronized关 键字都是线程安全的。将synchronized方法与对象作为锁 类MyObject.java文件代码
package chapter2.test2_1.test2_1_5;
public class MyObject {
public void methodA() {
try {
System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
Thread.sleep(3000);
System.out.println("end methodA threadName=" + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
自定义线程类ThreadA.java代码
package chapter2.test2_1.test2_1_5;
public class ThreadA extends Thread {
private MyObject object;
public ThreadA(MyObject object) {
super();
this.object = object;
}
@Override
public void run() {
super.run();
object.methodA();
}
}
自定义线程类ThreadB.java代码
package chapter2.test2_1.test2_1_5;
public class ThreadB extends Thread {
private MyObject object;
public ThreadB(MyObject object) {
super();
this.object = object;
}
@Override
public void run() {
super.run();
object.methodA();
}
}
运行类Run.java代码
package chapter2.test2_1.test2_1_5;
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
ThreadA a = new ThreadA(object);
a.setName("A");
ThreadB b = new ThreadB(object);
b.setName("B");
a.start();
b.start();
}
}
程序运行结果
两个线程可一同进入methodA()方法,因为该方法并没有 同步化。更改MyObject.java代码 在 methodA()方法前加入了关键字synchronized 进行同步处理。
package chapter2.test2_1.test2_1_5.test1;
public class MyObject {
synchronized public void methodA() {
try {
System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
Thread.sleep(3000);
System.out.println("end methodA threadName=" + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果
通过上面的示例得到结论,调用用关键字 synchronized声 明的方法一定是排队进行运行的。另外,需要牢牢记住 “共 享 ”这两个字,只有共享资源的读写访问才需要同步化,如果不是共享资源,那么就没有同步的必要。那其他方法在被调用时会是什么效果呢?如何查看将对象作为Lock锁的效果呢? 类文件MyObject.java代码
package chapter2.test2_1.test2_1_5.test2;
public class MyObject {
synchronized public void methodA() {
try {
System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end methodA threadName=" + Thread.currentThread().getName()+" end endTime=" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void methodB() {
try {
System.out.println("begin methodB threadName=" + Thread.currentThread().getName() + " begin time=" + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println("end methodB threadName=" + Thread.currentThread().getName() + " end time=" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
ThreadA
package chapter2.test2_1.test2_1_5.test2;
public class ThreadA extends Thread {
private MyObject object;
public ThreadA(MyObject object) {
super();
this.object = object;
}
@Override
public void run() {
super.run();
object.methodA();
}
}
ThreadB
package chapter2.test2_1.test2_1_5.test2;
public class ThreadB extends Thread {
private MyObject object;
public ThreadB(MyObject object) {
super();
this.object = object;
}
@Override
public void run() {
super.run();
object.methodB();
}
}
文件Run.java代码
package chapter2.test2_1.test2_1_5.test2;
public class Run {
public static void main(String[] args) {
MyObject object = new MyObject();
ThreadA a = new ThreadA(object);
a.setName("A");
ThreadB b = new ThreadB(object);
b.setName("B");
a.start();
b.start();
}
}
程序运行结果
通过上面的示例可以得知,虽然线程 A 先持有了 object对象的锁,但线程 B 完全可以异步调用非 synchronized类型的方法。在MyObject.java文件中的methodB()方法前加入synchronized关键字
package chapter2.test2_1.test2_1_5.test3.test2;
public class MyObject {
synchronized public void methodA() {
try {
System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
Thread.sleep(5000);
System.out.println("end methodA threadName=" + Thread.currentThread().getName() + " end endTime=" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized public void methodB() {
try {
System.out.println("begin methodB threadName=" + Thread.currentThread().getName() + " begin time=" + System.currentTimeMillis());
Thread.sleep(5000);
System.out.println("end methodB threadName=" + Thread.currentThread().getName() + " end time=" + System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果
结论如下
1 ) A 线程先持有 object 对象的 Lock 锁, B线程可以以异步的方式调用 object 对象中的非 synchronized 类型的方法。 2 ) A 线程先持有 object 对象的 Lock 锁, B线程如果在这时调用 object 对象中的 synchronized类型的方法,则需要等待,也就是同步。 3 )在方法声明处添加 synchronized并不是锁方法,而是锁当前类的对象。 4 )在 Java 中只有 “ 将对象作为锁 ” 这种说法,并没有 “锁方法 ” 这种说法。 5 )在 Java 语言中, “ 锁 ” 就是 “ 对象 ” , “ 对象 ”可以映射成 “ 锁 ”,哪个线程拿到这把锁,哪个线程就可以执行这个对象中的 synchronized 同步方法。 6 )如果在 X 对象中使用了 synchronized关键字声明非静态方法,则 X 对象就被当成锁。



