［java多线程］的同步问题

- 日理万妓 2023-06-12 09:19 107阅读 0赞

指的是多个线程同时修改一个过程时，可能导致的问题

## 引入： ##

以卖票问题为例：假设总共有十张票，三个黄牛卖票（代表三个子线程），预测最后一个黄牛卖完票，还剩下０张票

package se.SE.practice;
    class MyThread implements Runnable {
        private int ticket=10;
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if (this.ticket > 0) {
                    try {
                        // 模拟网络延迟
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "还剩下：" + this.ticket-- + "票");
                }
            }
        }
    }
    public class Thread1{
        public static void main(String[] args) {
            MyThread mt=new MyThread();
            Thread thread1=new Thread(mt,"黄牛1");
            Thread thread2=new Thread(mt,"黄牛２");
            Thread thread3=new Thread(mt,"黄牛３");
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

执行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA_size_16_color_FFFFFF_t_70][]

我们发现最后一个黄牛卖票还剩下1张票，和预期不符

为什么会出现这个问题呢？是因为在多线程并发执行的时候，发生了同步的问题，也就是多个线程同时访问同一块资源（ticket）

## 解决思路： ##

在黄牛线程访问ticket时，不允许有其他线程访问ticket

引入：synchronized关键字

Object someObject =new Object();
    synchronized (someObject){
      //此处的代码只有占有了someObject后才可以执行
    }

卖完票才解锁：在for循环后加synchronized(this)\{\}

也就是在任何一个时刻内只有一个线程在卖票，

三个线程（黄牛１，黄牛２，黄牛３）：可以同时进入for循环和run()但是不可同时进入synchroniazed锁住的代码块

public void run() {
            for (int i = 0; i < 100; i++) {
    
                synchronized (this) {
    //－－－－－－－－－－－－－－－－－－－－－－－－－－－
                    if (this.ticket > 0) {
                        try {
                            // 模拟网络延迟
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "还剩下：" + this.ticket-- + "票");
                    }
                }
    //-------------------------------------------------
            }
        }

## １同步问题： ##

a.同步代码块

在方法中使用synchronized对象，一般可以锁定当前this

表示同一时刻只有一个线程可以进入同步代码块，但是多个线程可以同时进入方法

b.同步方法

在方法声明中加入synchronized，表示此时只有一个线程可以进入方法

## ２synchronized对象锁 ##

观察以下代码：

１定义一个synchronized方法，锁住当前对象this

２第一次new了一个Syn对象syn1,记线程０，那么线程０

线程１启动创建Syn对象syn2,各自锁各自的对象

package se.SE.practice;
    class Syn{
        public synchronized void test(int ticket){
            System.out.println(Thread.currentThread().getName()+"此方法开始");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"此方法结束");
        }
    }
    class MyThread implements Runnable {
        private int ticket = 10;
        @Override
        public void run() {
            Syn syn=new Syn();
            syn.test(ticket);
        }
    }
    public class Thread1{
        public static void main(String[] args) {
                       MyThread myThread=new MyThread();
                Thread thread0=new Thread(myThread,"子线程０");
                Thread thread1=new Thread(myThread,"子线程１");
                Thread thread2=new Thread(myThread,"子线程２");
                thread0.start();
                thread1.start();
                thread2.start();
    /*for(int i=0;i<3;i++){
     new Thread(myThread,"线程"+i).start();
            }
    */
        }
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA_size_16_color_FFFFFF_t_70 1][]

总结：用synchronized(this)以及synchronized()只能防止多个线程执行同一个对象的同步段

synchronized锁的是括号中的对象而非代码

那么怎样才可以使得可以锁住一个对象呢，关键点在MyThread类实现Runnable 接口中只有一个对象syn

１定义Syn类对象syn

２通过有参构造函数实现对MyThread类对象个数的限制

package se.SE.practice;
    class Syn{
        public synchronized void test(int ticket){
            System.out.println(Thread.currentThread().getName()+"此方法开始");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"此方法结束");
        }
    }
    class MyThread implements Runnable {
        private int ticket = 10;
        private Syn syn;
        public MyThread(Syn syn){
            this.syn=syn;
        }
        @Override
        public void run() {
            this.syn.test(ticket);
        }
    }
    public class Thread1{
        public static void main(String[] args) {
            Syn syn=new Syn();
            MyThread myThread=new MyThread(syn);
            for(int i=0;i<3;i++){
            new Thread(myThread,"线程"+i).start();
            }
        }
    }

输出结果：

![20191113102202780.png][]

达到预期结果！

引入全局锁，从sychronized(this)或者synchronized方法只可以锁住当前对象，锁住代码段需要全局锁

## ３全局锁 ##

锁代码段

１使用类的静态方法，此时锁住的是当前使用的类，而非对象

也就是把public synchronized void test(int ticket)\{\}方法改为静态方法\--->public static synchronized void test(int ticket)\{\}

把类方法锁住－－就把代码块锁住

package se.SE.practice;
    class Syn{
        public synchronized void test(int ticket){
            System.out.println(Thread.currentThread().getName()+"此方法开始");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"此方法结束");
        }
    }
    class MyThread implements Runnable {
        private int ticket = 10;
        private Syn syn;
        @Override
        public void run() {
            this.syn.test(ticket);
        }
    }
    public class Thread1{
        public static void main(String[] args) {
            MyThread myThread=new MyThread();
            for(int i=0;i<3;i++){
            new Thread(myThread,"线程"+i).start();
            }
        }
    }

２在同步代码块中，锁当前的class对象，类名称.class

如果是锁普通方法：将普通方法的代码段放在synchronized(Syn.class)｛｝包含的代码段中

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191112224210850.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191113012848237.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjY0NTE2OA==,size_16,color_FFFFFF,t_70
[20191113102202780.png]: https://img-blog.csdnimg.cn/20191113102202780.png