[JAVA] 什么是Java线程同步机制？

最新推荐文章于 2024-08-26 23:57:38 发布

破晓*

最新推荐文章于 2024-08-26 23:57:38 发布

阅读量846

点赞数 10

文章标签： java

本文链接：https://blog.csdn.net/2301_79757798/article/details/141388386

版权

在单线程程序中，每次只能做一件事情，后面的事情需要等待前面的事情完成后才可以进行，如果使用多线程程序，就会发生两个线程抢占资源的问题，所以在多线程编程中，需要防止这些资源访问的冲突，Java提供线程同步的机制来防止资源访问的冲突。

如何理解同步机制？

举一个生活中的例子，比如一些景点，表演婚俗中抛绣球活动，这个绣球被抛出去以后，下面所有的游客都会去争抢这唯一的绣球，谁抢到绣球就是这个幸运的人，迎娶新娘。

我们能够发现，无论多少人在下面等待抢绣球，但最终，只有一个人能拿到这个绣球，成为唯一的幸运儿。在这个例子中，就是一个典型的同步机制。

1.同步块

在Java中提供了同步机制，可以有效地防止资源冲突，同步机制使用synchronized关键字。

synchronized（同步锁）关键字的作用就是利用一个特定的对象设置一个锁lock（绣球），在多线程（游客）并发访问的时候，同时允许一个线程（游客）可以获得这个锁，执行特定的代码（迎娶新娘）。执行后释放锁，继续由其他线程争抢

代码演示：

public class SyncSample {
    class Printer{
        public void print(){
            try {
                Thread.sleep(500);
                 System.out.print("魑");
                 Thread.sleep(500);
                 System.out.print("魅");
                 Thread.sleep(500);
                 System.out.print("魍");
                 Thread.sleep(500);
                 System.out.print("魉");
                 System.out.println( );
            }catch (Exception e){
                e.printStackTrace();
            }

        }

在SyncSample外部类中创建内部类Printer，在print（）方法体中，利用Thread.sleep(500)写入一个线程沉睡半秒输出的语句，使代码打印出有一个停顿的效果，作为sleep会抛出异常，我们用try—catch来捕获

再次增加内部类PrintTesk ，Runnable作为接口，在多线程编程中，Runnable接口通常与线程结合使用，用于创建新的线程来执行特定的任务。

可以通过将Runnable对象传递给Thread类的构造函数来创建一个新的线程，并在该线程中执行Runnable任务

 class PrintTask implements Runnable{
        public Printer printer;   //定义类的成员变量

        @Override
        public void run() {      //Runnable接口的核心方法run（）
            printer.print();     //调用printer对象的print方法，执行输出“魑魅魍魉”操作
        }
    }

再继续加入一个start方法，用于创建线程后实现输出

 public void start() {
        Printer printer = new Printer();//创建Printer类的实例
        for (int i = 0; i < 10; i++) {         //循环创建线程
            PrintTask tack = new PrintTask(); //在每次循环中，创建一个PrintTask对象tack，并将之前创建的printer对象赋值给tack的printer成员变量
            tack.printer = printer;
            Thread thread = new Thread(tack);    //创建一个新的Thread对象，将tack作为参数传入构造参数即这个线程会执行tack中的run方法
            thread.start();         //开始线程执行
        }
    }

最后在主函数调用

 public static void main(String[] args) {
        SyncSample syncSample = new SyncSample();
        syncSample.start();
    }

运动结果

我们发现，再多线程程序运行的时候，十个线程底层都是引用了同一个printer对象，这会使十个线程同时执行，同时对魑进行输出，然后又会对魅进行输出，接着魍魉进行一个个输出，最后得到以上无序混乱的结果。

在多线程情况下，所有线程都在争抢同一个资源，也就是当前printer对象时，使得我们打印出的数据并不是完整合适的，出现混乱的情况。

为了解决这样的问题，我们需要引入锁的机制，让线程一个个排队来执行，对于打印输出的代码，如果前面的线程没有执行完毕，后面所有的线程就一直处于阻塞等待的状态，直到拥有获取这个线程的执行权力

class Printer {
        Object lock =new Object();

        public void print() {
         synchronized (lock) {
             try {
                 Thread.sleep(500);
                 System.out.print("魑");
                 Thread.sleep(500);
                 System.out.print("魅");
                 Thread.sleep(500);
                 System.out.print("魍");
                 Thread.sleep(500);
                 System.out.print("魉");
                 System.out.println( );

             } catch (Exception e) {
                 e.printStackTrace();
             }
         }

Object lock = new Object();

在Printer内部类中加入了一个用于同步的对象锁，这个对象可以被多个线程用来进行同步操作，确保在同一时间只有一个线程能够访问被synchronized关键字修饰的代码块。

再次运行：

在程序运行时由Java来控制锁对象的分配，哪个线程优先的获取到了锁，哪个线程就可以执行里面的代码，这段代码执行完成后，锁会被释放，剩余的其他线程会争抢这把锁，之后按照相同的规则，抢夺—释放—抢夺，直到所有线程完成处理，程序结束。

关于synchronized的锁对象，synchronized用于实现线程同步的机制

synchronized代码块 -任意对象即可
synchronized方法 -this当前对象
synchronized静态方法 - 该类的字节码对象

1.synchronized代码块 -任意对象即可

同以上案例代码一样，内部类中新增锁对象lock，在代码中为了保证线程的同步，使用synchronized（）关键字，括号中增加锁对象lock，这样在多线程运行过程中，哪个线程先争抢到这个锁，它就拥有代码的执行权，其他线程处于阻塞状态

 class Printer {
        Object lock =new Object();   //定义锁对象

        public void print() {

         synchronized (lock) {

             try {
               
               ...............
               ...............

             } catch (Exception e) {

                 e.printStackTrace();
             }
         }

2.关于synchronized方法 -this当前对象

 public synchronized void print2  () {  //synchronized直接放在代码声明部分
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println( );

                } catch (Exception e) {
                    e.printStackTrace();
                
            }

此时synchronized不在代码中进行书写，而是把synchronized关键字放在声明部分，它是写在方法上进行描述，当一个方法被声明为synchronized时，多个线程在访问这个方法时会进行同步，既同一时间只有一个线程能够执行这个方法

synchronized方法使用的是对象锁，锁的对象是当前实例（this），表示一个线程进入一个sy实例方法后，它会获取当前对象的锁，其他线程如果想进入同一个对象这个synchronized方法，就必须等待当前线程释放这个锁

3.synchronized静态方法 - 该类的字节码对象

在Java中，当一个方法被声明为synchronized static（同步静态方法）时，它使用的锁是该类的字节码对象。

锁的对像

对于静态方法，锁的对象是类的class对象（该类的字节码对象），这意味着不同的对象实例在调用同一个类的synchronized static方法时，也会进行同步

public class SyncSample {
    static class Printer {     //添加静态方法
        Object lock =new Object();

        public void print1() {
         synchronized (lock) {
             try {
                 Thread.sleep(500);
                 System.out.print("魑");
                 Thread.sleep(500);
                 System.out.print("魅");
                 Thread.sleep(500);
                 System.out.print("魍");
                 Thread.sleep(500);
                 System.out.print("魉");
                 System.out.println( );

             } catch (Exception e) {
                 e.printStackTrace();
             }
         }

        }

 public static synchronized void print2  () { 
                try {
                    Thread.sleep(500);
                    System.out.print("魑");
                    Thread.sleep(500);
                    System.out.print("魅");
                    Thread.sleep(500);
                    System.out.print("魍");
                    Thread.sleep(500);
                    System.out.print("魉");
                    System.out.println( );

                } catch (Exception e) {
                    e.printStackTrace();

            }

与synchronized实例方法的区别：

锁的对象不同：
- synchronized实例方法锁的是当前对象实例（this）。
- synchronized static方法锁的是类的字节码对象。
同步范围不同：
- 对于实例方法，只有同一个对象实例的调用才会被同步。不同对象实例调用同一个实例方法是相互独立的，除非在方法内部有共享的状态。
- 对于静态方法，无论有多少个对象实例，只要是对同一个类的静态方法的调用，都会被同步。