同步和异步有什么区别？

雨点打透心脏的1/2处 2023-10-06 14:02 3阅读 0赞

同步问题引出，当多个线程需要访问同一个资源时，它们需要以某种顺序来确保该资源在某一时刻只能被一个线程使用，否则，程序运行结果将不可预料，在这种情况下就必须对数据进行同步。例如线程A需要使用Z资源，如果Z资源正在被B线程使用，同步机制就会让A等待，直到B线程结束对该资源的使用后，A线程才能使用Z资源，同步机制能够保证资源的安全。

## 如何实现同步？ ##

## 1.同步代码块 ##

加同步格式：  
synchronized( 需要一个任意的对象（锁） )\{  
代码块中放操作共享数据的代码。  
\}  
上述的格式称为多线程中的同步代码块。  
同步代码块上的锁，可以是随便任意的一个对象。

class SellTicketTask implements Runnable {
        
        int tickets = 100;//不要放到run方法中，不然就达不到多个线程卖同一个套票
        final Object lockObj = new Object(); //放在这里可以保证所有线程都共用同一个锁
        @Override
        public void run() {
        
            //不能在run方法中创建锁对象，因为每个线程都会执行这个方法创建独有的锁对象
            //我们要求，多个线程应该共用一个锁对象
            //Object lockObj = new Object();
    
            while (true) {
        
    
                synchronized (lockObj){
        //获取锁
                    //把操作资源，需要互斥访问的代码放在这里
                    if (tickets > 0) {
        
    
                        System.out.println(Thread.currentThread().getName() + "正在卖票：" + tickets);
    
                        tickets--;//出去一张，少一张票
                    }
    
                }//释放锁
    
    
    
    
                try {
        
                    Thread.sleep(50);//有异常只能捕获，因为父类型中的方法没有抛出异常
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
    
        }
    }

## 2.同步方法 ##

public class Demo {
        
        public static void main(String[] args) {
        
            SellTicketTask stt = new SellTicketTask();//只创建一个任务，供三个线程使用
            new Thread(stt, "【窗口1】").start();//stt.run
            new Thread(stt, "【窗口2】").start();//stt.run
            new Thread(stt, "【窗口3】").start();//stt.run
    
            //线程启动后，JVM会调用run方法，run方法内部就会调用 stt.run()
    
        }
    }
    
    class SellTicketTask implements Runnable {
        
        static int tickets = 100;//不要放到run方法中，不然就达不到多个线程卖同一个套票
        @Override
        public void run() {
        //run方法也是被this调用  stt.run this就是任务对象
    
            while (true) {
        
                // this.sellTicket(); //非静态同步方法
                sellTicket2(); //静态同步方法
    
                try {
        
                    Thread.sleep(50);//有异常只能捕获，因为父类型中的方法没有抛出异常
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
    
        }
    
        //this就是任务对象，多个线程都用同一个任务。可以保证多个线程使用的this锁是同一个锁对象。
        private synchronized void sellTicket() {
        //非静态方法 锁对象this  ==>  stt
            //this 锁
            if (tickets > 0) {
        
                System.out.println(Thread.currentThread().getName() + "正在卖票：" + tickets);
                tickets--;//出去一张，少一张票
            }
        }
    
        //如果静态的同方法 锁就是当前类型的字节码对象，也是只有一份数据
        private static synchronized void sellTicket2() {
        
            if (tickets > 0) {
        
                System.out.println(Thread.currentThread().getName() + "正在卖票：" + tickets);
                tickets--;//出去一张，少一张票
            }
        }
    }

3.lock锁（同步锁）

- public void lock():加同步锁。     //相当于同步代码块开始   synchronized{
        
    - public void unlock():释放同步锁。 //相当于同步代码块结束   }

//1. 根据子类ReentrantLock实例化Lock锁对象
    //2. 保证多个线程使用相同的Lock锁对象
    //3. lock()方法执行就是开始锁
    //4. unlock()方法执行释放锁
    
    class SellTicketTask implements Runnable {
        
        int tickets = 100;//不要放到run方法中，不然就达不到多个线程卖同一个套票
        Lock lock = new ReentrantLock();//创建了一个Lock对象
    
        @Override
        public void run() {
        
    
            while (true) {
        
                lock.lock();// 相当于同步代码块的开始
                try {
        
                    if (tickets > 0) {
        
    
                        System.out.println(Thread.currentThread().getName() + "正在卖票：" + tickets);
    
                        tickets--;//出去一张，少一张票
                    }
                }finally {
        
                    //可以保证一定释放锁
                    lock.unlock(); //同步代码块结束
                }
    
                try {
        
                    Thread.sleep(50);//有异常只能捕获，因为父类型中的方法没有抛出异常
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
    
    
            }
    
        }
    }