栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

java 多线程&synchronized同步方法——24

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

java 多线程&synchronized同步方法——24

关键字synchronized作用
关键字 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.NetProperties NetProperties.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.DefaultProxySelector DefaultProxySelector.java 92
 java.lang.Class forName0 Class.java -2
 java.lang.Class forName Class.java 264
 java.net.ProxySelector ProxySelector.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.Socket Socket.java 451
 java.net.Socket Socket.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.Hashtable Hashtable.java 191
 java.util.Hashtable Hashtable.java 212
 java.util.Properties Properties.java 148
 java.util.Properties Properties.java 140
 sun.net.NetProperties NetProperties.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.DefaultProxySelector DefaultProxySelector.java 92
 java.lang.Class forName0 Class.java -2
 java.lang.Class forName Class.java 264
 java.net.ProxySelector ProxySelector.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.Socket Socket.java 451
 java.net.Socket Socket.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.Socket Socket.java 451
 java.net.Socket Socket.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=200

Process 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."":()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>
字节码中使用 monitorenter和 monitorexit指令进行同步 处理。 经过前面的测试,我们可以明白同步与异步 的区别。
同步:按顺序执行 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 对象就被当成锁。
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/955982.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号