Java 线程同步详解

java 线程同步根本上是要符合一个逻辑:加锁------>修改------>释放锁

1、同步代码块

示例如下：

public class syncblock {
  static class datawrap {
    int i;
  }
  
  static class syncblockthread extends thread {
    private datawrap date;
    
    public syncblockthread(datawrap datawrap) {
      this.date = datawrap;
    }
    
    @override
    public void run() {
      
      for (int i = 0; i < 10; i++) {
        synchronized (date) {
          date.i++;
          try {
            sleep(1);
          } catch (interruptedexception e) {
            e.printstacktrace();
          }
          system.out.println(getname() + " " + date.i);
        }
      }
    }
  }
  
  public static void main(string[] args) {
    //多线程实现变量i依次加一输出
    datawrap datawrap = new datawrap();
    
    new syncblockthread(datawrap).start();
    new syncblockthread(datawrap).start();
    new syncblockthread(datawrap).start();
  }

}

示例中希望按照顺序依次输出整数。

通常同步代码块是需要锁定的对象，一般是需要并发访问的共享资源，任何线程在修改指定资源之前都首先对该资源加锁，在加锁期间其它线程无法修改该资源。从而保证了线程的安全性。另外线程在调用sleep或者yield时并不会让出资源锁。

2、同步方法

public class syncmethod {
  
  static class datawrap{
    int i;
    
    public synchronized void valuegrow(){
      i++;
      
      try {
        thread.sleep(1);
      } catch (interruptedexception e) {
        // todo auto-generated catch block
        e.printstacktrace();
      }
      system.out.println(thread.currentthread().getname() + " " + i);
    }
  }
  
  static class syncmethodthread extends thread {
    datawrap datawrap;
    
    public syncmethodthread(datawrap datawrap){
      this.datawrap = datawrap;
    }
    
    @override
    public void run() {
      for (int i = 0; i < 10; i++) {
        datawrap.valuegrow();  
      }
    }
  }
  
  public static void main(string[] args) {
    //实现顺序增长并输出datawrap中的i
    
    datawrap datawrap = new datawrap();
    
    new syncmethodthread(datawrap).start();
    new syncmethodthread(datawrap).start();
    new syncmethodthread(datawrap).start();
  }

}

同步方法是使用synchronized关键字修饰的某个方法，同步方法锁定的就是该对象本身，所以当一个线程调用了某个对象的同步方法后，如有其它线程调用该对象的其它同步方法，也依然要等待释放该对象的锁，因为该对象已被锁定。

3、同步锁

通过定义同步锁对象实现同步，这种情况下，同步锁使用lock对象充当。

import java.util.concurrent.locks.lock;
import java.util.concurrent.locks.reentrantlock;

public class synclock {

  static class datawrap{
    lock lock = new reentrantlock();
    int i;
    
    public void valuegrow(){
      lock.lock();
      try {
        i++;
        
        try {
          thread.sleep(1);
        } catch (interruptedexception e) {
          // todo auto-generated catch block
          e.printstacktrace();
        }
        system.out.println(thread.currentthread().getname() + " " + i);  
      } finally {
        lock.unlock();
      }
      
    }
  }
  
  static class synclockthread extends thread {
    datawrap datawrap;
    
    public synclockthread(datawrap datawrap){
      this.datawrap = datawrap;
    }
    
    @override
    public void run() {
      for (int i = 0; i < 10; i++) {
        datawrap.valuegrow();  
      }
    }
  }
  
  public static void main(string[] args) {
    //实现顺序增长并输出datawrap中的i
    
    datawrap datawrap = new datawrap();
        
    new synclockthread(datawrap).start();
    new synclockthread(datawrap).start();
    new synclockthread(datawrap).start();
  }

}

使用锁对象实现线程同步会更灵活一些，某些锁还具有一些特定的功能，其中比较常用的readwritelock读写锁，reentrantlock可重入锁。