java多线程-2-线程安全及实现线程同步的三种方式

水深无声 2023-01-10 14:35 140阅读 0赞

### 文章目录 ###

*   *  线程安全的概念
     *  线程同步的三种方式
     *   *  1 同步代码块
         *  2 同步方法
         *  3 同步锁
         *  三种同步方式的总结
     *  练习

## 线程安全的概念 ##

线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他操作，调用这个对象的行为都可以获得正确的结果，那么这个对象就是线程安全的。  
或者说：一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性，也就是说我们不用考虑同步的问题。  
线程安全问题大多是由全局变量及静态变量引起的，局部变量逃逸也可能导致线程安全问题。  
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。  
类要成为线程安全的，首先必须在单线程环境中有正确的行为。如果一个类实现正确(这是说它符合规格说明的另一种方式)，那么没有一种对这个类的对象的操作序列(读或者写公共字段以及调用公共方法)可以让对象处于无效状态，观察到对象处于无效状态、或者违反类的任何不可变量、前置条件或者后置条件的情况。  
此外，一个类要成为线程安全的，在被多个线程访问时，不管运行时环境执行这些线程有什么样的时序安排或者交错，它必须仍然有如上所述的正确行为，并且在调用的代码中没有任何额外的同步。其效果就是，在所有线程看来，对于线程安全对象的操作是以固定的、全局一致的顺序发生的。  
正确性与线程安全性之间的关系非常类似于在描述 ACID(原子性、一致性、独立性和持久性)事务时使用的一致性与独立性之间的关系：从特定线程的角度看，由不同线程所执行的对象操作是先后(虽然顺序不定)而不是并行执行的。  
线程状态分类

## 线程同步的三种方式 ##

共100张票，三个售票窗口同时卖票。

*  问题：卖票过程中，出现重票、错票 ==> 出现线程安全问题
 *  问题出现原因：当某个线程操作车票的过程中，尚未完成操作时，其它线程参与进来，也操作车票，没能保证对共享资源（ticket）的互斥访问
 *  解决：当任何一个线程操作ticket的时候，其余线程都必须等待，直至当前操作ticket的线程操作结束，在此期间，就算当前线程阻塞，其余线程也必须等待

### 1 同步代码块 ###

**1 使用方式**

synchronized(同步监视器){ 
     	// 需要被同步的代码
     }

说明：

1.  操作共享数据的代码，即为需要被同步的代码。被synchronized关键字包围的同步代码不能多也不能少，少了起不到互斥效果，多了则影响线程并发效率，甚至影响程序正确性。
2.  共享数据，即多个线程都需要操作的变量。如本例中的ticket。
3.  同步监视器，即 **锁**。任何一个类的对象都可以充当锁。但**操作共享数据的多个线程必须使用同一把锁**。

**2 程序代码实现**

实现Runnable接口

class TicketWindow implements Runnable { 
        private int ticket = 100;
        private Object obj = new Object();
    
        @Override
        public void run() { 
            while (true) { 
                synchronized (obj) { 
                    if (ticket > 0) { 
                        try { 
                            Thread.sleep(100);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + " 卖出第 " + ticket + " 张票");
                        ticket--;
                    } else { 
                        break;
                    }
                }
            }
        }
    }
    
    public class ThreadSync { 
        public static void main(String[] args) { 
            TicketWindow ticketWindow = new TicketWindow();
    
            Thread thread1 = new Thread(ticketWindow);
            Thread thread2 = new Thread(ticketWindow);
            Thread thread3 = new Thread(ticketWindow);
    
            thread1.setName("售票窗口1");
            thread2.setName("售票窗口2");
            thread3.setName("售票窗口3");
    
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

继承Thread类

class TicketWindow1 extends Thread { 
        private static int ticket = 100;
        private static Object obj = new Object();
    
        @Override
        public void run() { 
            while (true) { 
                synchronized (obj) { 
                    if (ticket > 0) { 
                        try { 
                            Thread.sleep(100);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + " 卖出第 " + ticket + " 张票");
                        ticket--;
                    } else { 
                        break;
                    }
                }
            }
        }
    }
    
    public class ThreadSync1 { 
        public static void main(String[] args) { 
            Thread thread1 = new TicketWindow1();
            Thread thread2 = new TicketWindow1();
            Thread thread3 = new TicketWindow1();
    
            thread1.setName("售票窗口1");
            thread2.setName("售票窗口2");
            thread3.setName("售票窗口3");
    
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

**3 同步监视器（锁）的选择**

> 通过实现Runnable接口实现的多线程

方式一：使用第三方对象

class TicketWindow implements Runnable { 
        private int ticket = 100;
        private Object obj = new Object();
    
        @Override
        public void run() { 
            while (true) { 
                synchronized (obj) { 
                      // ……
                }
            }
        }
    }

方式二：使用this关键字

class TicketWindow implements Runnable { 
        private int ticket = 100;
    
        @Override
        public void run() { 
            while (true) { 
            	// 此处的this指的是TicketWindow ticketWindow = new TicketWindow(); 中的 ticketWindow 
                synchronized (this) { 
                      // ……
                }
            }
        }
    }

方式三：使用当前类的Class对象

class TicketWindow implements Runnable { 
        private int ticket = 100;
    
        @Override
        public void run() { 
            while (true) { 
            	// Class cls = TicketWindow.class;
                synchronized (TicketWindow.class) { 
                      // ……
                }
            }
        }
    }

> 通过继承Thread类实现的多线程

方式一：使用第三方对象

class TicketWindow1 extends Thread { 
        private static int ticket = 100;
        // 注意：第三方对象必须使用static修饰，否则变成成员变量，多个线程都有一份，则锁不唯一，起不到互斥效果
        private static Object obj = new Object();
    
        @Override
        public void run() { 
            while (true) { 
                synchronized (obj) { 
                    // ……
                }
            }
        }
    }

方式二：使用当前类的Class对象

class TicketWindow1 extends Thread { 
        private static int ticket = 100;
    
        @Override
        public void run() { 
            while (true) { 
            	// Class cls = TicketWindow1.class;
                synchronized (TicketWindow1.class) { 
                    // ……
                }
            }
        }
    }

注：通过继承Thread方式实现的多线程，慎用this关键字作为同步监视器。比如上例：

Thread thread1 = new TicketWindow1();
    Thread thread2 = new TicketWindow1();
    Thread thread3 = new TicketWindow1();
    
    class TicketWindow1 extends Thread { 
        private static int ticket = 100;
    
        @Override
        public void run() { 
            while (true) { 
            	// 因为分别创建了三个子类对象，则每个this指向一个子类对象，则锁不唯一，起不到同步效果
                synchronized (this) { 
                    // ……
                }
            }
        }
    }

### 2 同步方法 ###

如果操作共享数据的代码完整的声明在一个方法中，可以将此方法声明为同步的。

**1 使用方式**

访问修饰符 synchronized 返回值 方法名(参数列表) { 
    	// 同步代码块
    }
    
    或
    
    访问修饰符 static synchronized 返回值 方法名(参数列表) { 
    	// 同步代码块
    }

说明：

1.  同步方法仍然涉及到同步监视器，只是不需要我们显示声明。
2.  非静态的同步方法，同步监视器为this；静态的同步方法，同步监视器是当前类的Class对象（当前类本身），即 xxx.class。

**2 程序代码实现**

实现Runnable接口

class TicketWindow implements Runnable { 
        private int ticket = 100;
    
        @Override
        public void run() { 
            while (ticket > 0) { 
                sellTicket();
            }
        }
    
        public synchronized void sellTicket() { 
            if (ticket > 0) { 
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
                System.out.println(Thread.currentThread().getName() + " 卖出第 " + ticket + " 张票");
                ticket--;
            }
        }
    }
    
    public class ThreadSync { 
        public static void main(String[] args) { 
            TicketWindow ticketWindow = new TicketWindow();
    
            Thread thread1 = new Thread(ticketWindow);
            Thread thread2 = new Thread(ticketWindow);
            Thread thread3 = new Thread(ticketWindow);
    
            thread1.setName("售票窗口1");
            thread2.setName("售票窗口2");
            thread3.setName("售票窗口3");
    
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

继承Thread类

class TicketWindow1 extends Thread { 
        private static int ticket = 100;
    
        @Override
        public void run() { 
            while (ticket > 0) { 
                sellTicket();
            }
        }
    
        /** * 通过继承Thread类实现的多线程，同步方法必须为静态方法，因为非静态的同步方法，同步监视器为this， * Thread thread1 = new TicketWindow1(); * Thread thread2 = new TicketWindow1(); * Thread thread3 = new TicketWindow1(); * 而上述的this不唯一，因此无法实现对共享资源的互斥访问。 */
        public static synchronized void sellTicket() { 
            if (ticket > 0) { 
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
                System.out.println(Thread.currentThread().getName() + " 卖出第 " + ticket + " 张票");
                ticket--;
            }
        }
    }
    
    public class ThreadSync1 { 
        public static void main(String[] args) { 
            Thread thread1 = new TicketWindow1();
            Thread thread2 = new TicketWindow1();
            Thread thread3 = new TicketWindow1();
    
            thread1.setName("售票窗口1");
            thread2.setName("售票窗口2");
            thread3.setName("售票窗口3");
    
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

### 3 同步锁 ###

从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

**1 使用方式**

// 1 获得一个锁
    Lock lock = new ReentrantLock();
    
    // 2 加锁
    lock.lock();
    // 同步代码块
    
    // 3 解锁
    lock.unlock();

**2 代码实现**

class TicketWindowLock implements Runnable { 
        private int ticket = 100;
        // 1 获得一个锁
        private Lock lock = new ReentrantLock();
        /** * private ReentrantLock lock = new ReentrantLock(true); * 带参数的构造方法：ReentrantLock(boolean fair); ==> 公平锁 * 所谓公平锁：假设现在三个卖票线程按 1、2、3 顺序先后到达并争取锁，但是窗口1获得了锁并卖票， * 窗口2、3等待，等窗口1释放锁后，窗口2、3再按顺序获得锁并卖票，保证按照先到先得的顺序获得锁， * 以此保证公平性。 * * 若是使用无参构造方法获得锁，则不保证公平性。同样的，三个卖票线程按 1、2、3 顺序先后到达并 * 争取锁，但是窗口1获得了锁并卖票，窗口2、3等待，窗口1释放锁后，有可能再次获得锁并卖票，窗 * 口2、3仍然等待，不保证公平性。 */
    
        @Override
        public void run() { 
            while (true) { 
    
                try { 
                    // 2 上锁
                    lock.lock();
    
                    if (ticket > 0) { 
                        try { 
                            Thread.sleep(100);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + " 卖出第 " + ticket + " 张票");
                        ticket--;
                    } else { 
                        break;
                    }
                } catch (Exception e) { 
                    e.printStackTrace();
                } finally { 
                    // 3 解锁。使用 try catch finally，将解锁操作放在finally语句块中，保证锁一定会被释放
                    lock.unlock();
                }
            }
        }
    }
    
    public class ThreadSync2 { 
        public static void main(String[] args) { 
            TicketWindowLock ticketWindowLock = new TicketWindowLock();
    
            Thread thread1 = new Thread(ticketWindowLock);
            Thread thread2 = new Thread(ticketWindowLock);
            Thread thread3 = new Thread(ticketWindowLock);
    
            thread1.setName("售票窗口1");
            thread2.setName("售票窗口2");
            thread3.setName("售票窗口3");
    
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

### 三种同步方式的总结 ###

1.  synchronized （同步代码块与同步方法）与 Lock 的异同。  
    相同：都能解决现场安全问题  
    不同：synchronized机制在执行完相应的同步代码后，自动释放同步监视器；Lock需要手动的启动同步（lock()），同步结束也需要手动的实现（unlock()）
2.  三种方式的建议使用顺序。  
    Lock锁 ⇒ 同步代码块 ⇒ 同步方法

## 练习 ##

有一个初始余额为0元的账户，甲、乙两人向此账户存钱，每人每次存1000元，每人存10次。编写程序实现功能。

分析：两人可能同时对账户余额进行操作，故应该保证两人互斥操作，防止读取不正确的数据，使账户余额出错。

class Account { 
        // 账户余额
        private int balance;
    
        public Account(int money) { 
            this.balance = money;
        }
    
        /** * 存钱方法，每次向账户存指定金额的钱 * @param money 存钱数额 * * 非静态同步方法实现同步，同步监视器为this，即Account的对象 */
        public synchronized void deposit(int money) { 
            if (money > 0) { 
                balance += money;
    
                try { 
                    Thread.sleep(150);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
                System.out.println(Thread.currentThread().getName()
                        + " 向账户存进1000元，账户余额为 " + balance + " 元");
            }
        }
    }
    
    class SaveMoneyThread extends Thread { 
        private Account account;
    
        public SaveMoneyThread(Account account) { 
            this.account = account;
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                // account调用deposit()方法，两个Thread子类以同一个account为参数创建线程，共享
                // 一个account锁，故能实现互斥
                account.deposit(1000);
            }
        }
    }
    public class SaveMoneyTest { 
        public static void main(String[] args) { 
            Account account = new Account(0);
            SaveMoneyThread saveMoneyThread1 = new SaveMoneyThread(account);
            SaveMoneyThread saveMoneyThread2 = new SaveMoneyThread(account);
            saveMoneyThread1.setName("甲");
            saveMoneyThread2.setName("乙");
            saveMoneyThread1.start();
            saveMoneyThread2.start();
        }
    }

甲 向账户存进1000元，账户余额为 1000 元
    甲 向账户存进1000元，账户余额为 2000 元
    乙 向账户存进1000元，账户余额为 3000 元
    乙 向账户存进1000元，账户余额为 4000 元
    乙 向账户存进1000元，账户余额为 5000 元
    甲 向账户存进1000元，账户余额为 6000 元
    乙 向账户存进1000元，账户余额为 7000 元
    甲 向账户存进1000元，账户余额为 8000 元
    乙 向账户存进1000元，账户余额为 9000 元
    甲 向账户存进1000元，账户余额为 10000 元
    乙 向账户存进1000元，账户余额为 11000 元
    乙 向账户存进1000元，账户余额为 12000 元
    乙 向账户存进1000元，账户余额为 13000 元
    乙 向账户存进1000元，账户余额为 14000 元
    甲 向账户存进1000元，账户余额为 15000 元
    甲 向账户存进1000元，账户余额为 16000 元
    乙 向账户存进1000元，账户余额为 17000 元
    甲 向账户存进1000元，账户余额为 18000 元
    甲 向账户存进1000元，账户余额为 19000 元
    甲 向账户存进1000元，账户余额为 20000 元
    
    Process finished with exit code 0