Java多线程 – 线程同步

一、线程安全问题

  在多线程编程中，极容易出现一个问题，即线程安全。举个栗子~，如果此时火车站有十张余票，四个售票口，此时四个售票口相当于四个线程，他们一同运转，卖票，那么就会出现一个很经典的安全问题。

示例代码：

class demo{ public static void main(String[] args) throws InterruptedException { Train train = new Train(); Train train1 = new Train(); Train train2 = new Train(); Train train3 = new Train(); train.start(); train1.start(); train2.start(); train3.start(); } } class Train extends Thread{ private static int count = 10; @Override public void run(){ while (true){ try{ Thread.sleep(500); boolean flag = sale(); if(!flag) break; }catch (InterruptedException e){ e.printStackTrace(); } } } public boolean sale(){ if(count > 0){ --count; System.out.println( Thread.currentThread().getName() + "售出一张,剩余："+count); return true; }else{ return false; } } }

大家可以运行一下以上的程序，会发现有的时候售出的票不只是10张，这正是线程调度的不确定性，

二、同步代码块

  之所以出现以上的情况，是因为run()方法的方法体不具有同步安全性，当多个线程同步修改同一变量的时候容易出现以上情况，为了解决这个尴尬的问题，Java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。

synchronized(obj){ //此处代码就是同步代码块 }

  注意：任何时刻都只能拥有一个线程获得对同步监视器的锁定，当同步代码块执行完成之后，该线程就会释放对同步监视器的锁定。

class demo{ public static void main(String[] args) throws InterruptedException { Train train = new Train(); Train train1 = new Train(); Train train2 = new Train(); Train train3 = new Train(); train.start(); train1.start(); train2.start(); train3.start(); } } class Train extends Thread{ private static int count = 10; @Override public void run(){ //获取类锁 synchronized(Train.class){ while (true){ try{ Thread.sleep(500); boolean flag = sale(); if(!flag) break; }catch (InterruptedException e){ e.printStackTrace(); } } } } public boolean sale(){ if(count > 0){ --count; System.out.println( Thread.currentThread().getName() + "售出一张,剩余："+count); return true; }else{ return false; } } }

三、同步方法

  与同步代码块相对应，Java的多线程安全支持，还提供了同步方法，同步方法就是使用synchronized修饰的实例方法（非static方法），则该方法称为同步方法，对于synchronized修饰的实例方法，无需显式指定同步监视器，同步方法的同步监视器是this，也就是调用该方法的对象。   通过同步方法可以非常方便地实现线程安全的类。   线程安全的类有以下的特征：    1. 该类的对象可以被多个线程安全的访问。    2. 每个线程调用该对象的任意方法之后都将得到正确结果。    3. 每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。

注意：synchronized可以修饰方法和代码块，但不能修饰构造器和成员变量等

四、释放同步监视器的锁定

  任何线程进入同步代码块或同步方法前，都必须先获得对同步监视器的锁定，那么何时会释放对同步监视器的锁定呢？程序无法显示释放对同步监视器的锁定，而是在以下这些情况释放对同步监视器的锁定：   1. 当前线程的同步方法、同步代码执行结束，当前线程即释放同步监视器。   2. 当前线程在同步代码块、同步方法中遇到了break，return终止了该代码块、该方法的继续执行，当前线程将会释放同步监视器。   3. 当前线程在同步代码块、同步方法之中出现了未处理的error或Exception，导致了该代码块，该方法异常结束的时候，当前线程将会释放同步监视器。   4. 当前线程执行同步代码块或同步方法时，程序执行了同步监视器对象的wait()方法，则当前线程暂停，并且释放同步监视器。

  以下情况，线程不会释放同步监视器：   1. 线程执行同步代码块或者同步方法的时候，程序调用Thread.sleep()、Thread.yield()方法来暂停当前线程的执行，但是当前线程并不会释放同步监视器。   2. 线程执行同步代码块的时候，其他的线程调用该线程的suspend()方法将其挂起，该线程不会释放同步监视器，当然，需要注意的是：程序中尽量少使用suspend()和resume()方法来控制线程。

五、同步锁

  从Java 5开始，Java提供了一种功能更强大的线程同步机制 – 通过显示定义同步锁对象来实现同步。   Lock提供了比synchronized方法和代码块更广泛的锁定操作，Lock允许实现更加灵活的结构，可以具有差别很大的属性，并且支持多个相关的Condition对象。   Lock是控制多个线程对共享资源进行访问的工具。通常，所提供了对共享资源的独占访问，每次都只能有一个线程对Lock对象枷锁，线程开始访问共享资源之前，应该先获得Lock对象。   某些所可能允许对共享资源并发操作，例如说：ReadWriteLock（读写锁）,Lock和ReadWriteLock是Java 5提供的两个根接口，且为Lock提供了ReentrantLock（可重入锁）实现类，为ReadWreiteLock提供了ReentrantReadWriteLock实现类。   Java 8新增了新型的StampedLock类，在大多数场景中他可以替代传统的ReentrantreadWriteLock。ReentrantreadWriteLock为读写操作提供了三种锁模式：Writing、ReadingOptimisitic、Reading。   在实现线程安全的控制之中，较为常用的是ReentrantLock（可重入锁）。使用该Lock对象可以显式地添加所和释放锁。

import java.util.concurrent.locks.ReentrantLock; class demo{ //定义锁对象 private final ReentrantLock lock = new ReentrantLock(); //定义需要保证线程安全的方法 public void m(){ //加锁 lock.lock(); try{ //需要保证线程安全的代码 } //使用finally块来释放锁 finally { //解锁 lock.unlock(); } } }

  使用ReentrantLock对象进行同步，加锁和释放锁均出现在不同的额作用范围之内，通常建议使用finally块来确保在必要的时候释放锁，通常使用ReentrantLock对象。

六、避免死锁

  当两个线程相互等待对方释放同步监视器就会发生死锁，其中Java虚拟机中没有监测，也没有采取措施处理死锁情况，所以多线程编程中应当精良避免死锁出现，一旦出现死锁，整个程序既不会发生任何异常，也不会有任何提示，只是所有线程处于阻塞状态，无法继续。

  死锁不应该在程序中出现，编写时应该尽量避免死锁。   1. 避免多次锁定，尽量避免同一个线程对多个同步监视器进行锁定   2. 具有相同的加锁顺序，如果多个线程对多个同步监视器进行锁定，则应该报这个它们以相同的顺序请求加锁。   3. 采用定时所，程序调用Lock对象的truLock()方法加锁时，可以指定time和unit参数，当超过指定时间就会自动释放对Lock的锁定。   4. 死锁检测，这是依靠算法进行实现的死锁预防措施，主要针对那些不可能实现按序加锁，也不可能使用定时锁的场景。

//会产生死锁的代码： class A{ public synchronized void foo(B b){ System.out.println("线程名：" + Thread.currentThread().getName() + "进入A实例的foo方法"); try{ Thread.sleep(200); } catch (InterruptedException e){ e.printStackTrace(); } System.out.println("线程名：" + Thread.currentThread().getName() + "企图调用B实例的Last方法"); b.last(); } public synchronized void last(){ System.out.println("进入A类的last方法内部"); } } class B{ public synchronized void foo(A a){ System.out.println("线程名：" + Thread.currentThread().getName() + "进入A实例的foo方法"); try{ Thread.sleep(200); } catch (InterruptedException e){ e.printStackTrace(); } System.out.println("线程名：" + Thread.currentThread().getName() + "企图调用B实例的Last方法"); a.last(); } public synchronized void last(){ System.out.println("进入B类的last方法内部"); } } public class demo implements Runnable{ A a = new A(); B b = new B(); public void init(){ Thread.currentThread().setName("主线程"); a.foo(b); System.out.println("进入主线程之后"); } @Override public void run(){ Thread.currentThread().setName("副线程"); b.foo(a); System.out.println("进入副线程"); } public static void main(String[] args) { demo d = new demo(); new Thread(d).start(); d.init(); } }