java互斥锁和读写锁 java线程互斥锁

一个多线程的程序，两个或者多个线程可能需要访问同一个数据资源。这时就必须考虑数据安全的问题，需要线程互斥或者同步。

线程的互斥

当多个线程需要访问同一资源时，要求在一个时间段内只能允许一个线程来操作共享资源，操作完毕后别的线程才能读取该资源，这叫线程的互斥。我们需要使用synchronized来给共享区域加锁，确保共享资源安全。
如果一个线程调用了某个对象的synchronized方法，它在这个方法运行完之前不会被别的线程打断，这就是线程的同步机制。一般将共享资源放在这个同步方法内部，这样就保证在一个线程对这个资源操作完之后别的线程才可以访问。
将共享资源放在同步方法或者同步代码块中可以保证一个线程对共享资源操作时不会被打断，凡是被synchronized修饰的资源，在运行的时候系统都要给它们分配一个管理程序，这需要消耗一部分资源。

使用示例

class NumCount
{
   public int count = 0;

   public synchronized void run()
   {
      for (int i = 1; i <= 100; i++)
      {
         Thread thread = Thread.currentThread();
         count = count + 1;
         System.out.printf("%s第%d次计数，count值为：%d\n", thread.getName(), i, count);
         try
         {
            // 睡眠5毫秒，给其它线程运行机会
            Thread.sleep(5);
         }
         catch (InterruptedException e)
         {
            e.printStackTrace();
         }
      }
   }
}

class SynchThread extends Thread
{
   private NumCount numCount = null;

   public SynchThread(String name, NumCount numCount)
   {
      super(name);
      this.numCount = numCount;
   }

   @Override
   public void run()
   {
      numCount.run();
   }
}

/**
 * 线程间互斥
 * 
 * @author jianggujin
 *
 */
public class SyncThreadDemo
{
   public static void main(String[] args)
   {
      NumCount numCount = new NumCount();
      SynchThread synchThread1 = new SynchThread("Thread-1", numCount);
      SynchThread synchThread2 = new SynchThread("Thread-2", numCount);
      SynchThread synchThread3 = new SynchThread("Thread-3", numCount);
      synchThread1.start();
      synchThread2.start();
      synchThread3.start();
      try
      {
         synchThread1.join();
         synchThread2.join();
         synchThread3.join();
      }
      catch (InterruptedException e)
      {
         e.printStackTrace();
      }
      System.out.println("计数器的值为：" + numCount.count);
   }
}

最后运行的结果计数器的值为300，大家可以尝试一下把synchronized 去掉，结果可能就会改变。

线程的同步

在某些情况下，线程需要交替执行。比如一个线程向一个存储单元执行存放数据，而另一个操作执行取值操作，线程间同步完成这个存取任务，需要将这些线程同步。要解决线程交替执行但是又要保证共享资源安全，这需要使用到JAVA3个方法：wait()、notify()和nodifyAll()、这3个方法是Object类的成员方法，所以在任何类中都可以使用这3个方法。

返回值	方法名	说明
public final void	wait()	使当前线程睡眠，直到其它线程进入管程唤醒它
public final void	notify()	唤醒此对象等待池中第一个调用wait()方法的线程
public final void	nodifyAll()	唤醒此对象等待池中所有睡眠的线程

生产者-消费者问题是操作系统中的一个著名进程同步的问题。这个问题用线程思想表达出来就是说有一些生产线程产生数据放置在公共区，一些消费线程去提取消费数据。在这个问题中要保护公共资源的安全性，在生产者生产物资时消费线程必须等待不能打断生产线程，当生产到一定数量时，生产线程暂停让消费线程提取数据。我们来通过一个例子来演示这个过程：

import java.util.Vector;

/**
 * 工厂
 * 
 * @author jianggujin
 *
 */
class Factory
{
   private Vector<String> goods;
   // 标志货物上限
   private int goodFlag = 5;

   public Factory()
   {
      goods = new Vector<String>();
   }

   public synchronized void production()
   {
      if (goods.size() < goodFlag)
      {
         goods.addElement("货物" + (goods.size() + 1));
         System.out.printf("%s生产货物：货物%d，现有货物数量：%d\n", Thread.currentThread().getName(),
             (goods.size() + 1),
               goods.size());
         // 唤醒消费线程
         notifyAll();
      }
      else
      {
         System.out.println("货物已满可以取货");
         try
         {
            // 货物满等待消费
            wait();
         }
         catch (InterruptedException e)
         {
            System.out.println("生产事故...");
         }
      }
   }

   public synchronized void getProduction()
   {
      if (goods.size() < 1)
      {
         try
         {
            System.out.println("货物取完...");
            // 等待生产
            wait();
         }
         catch (InterruptedException e)
         {
            System.out.println("账户余额不足...");
         }
      }
      else
      {
         System.out.printf("%s取走货物：%s，还有货物数量：%d\n", Thread.currentThread().getName(),
             goods.elementAt(goods.size() - 1),
               goods.size());
         goods.remove(goods.size() - 1);
         // 唤醒生产线程
         notifyAll();
      }
   }
}

/**
 * 生产者
 * 
 * @author jianggujin
 *
 */
class ProductThread extends Thread
{
   private Factory factory = null;

   public ProductThread(String name, Factory factory)
   {
      super(name);
      this.factory = factory;
   }

   @Override
   public void run()
   {
      while (true)
      {
         factory.production();
         try
         {
            Thread.sleep(10);
         }
         catch (InterruptedException e)
         {
            System.out.println("生产事故...");
         }
      }
   }
}

/**
 * 消费者
 * 
 * @author jianggujin
 *
 */
class ConsumThread extends Thread
{
   private Factory factory = null;

   public ConsumThread(String name, Factory factory)
   {
      super(name);
      this.factory = factory;
   }

   @Override
   public void run()
   {
      while (true)
      {
         factory.getProduction();
         try
         {
            Thread.sleep(10);
         }
         catch (InterruptedException e)
         {
            System.out.println("账户余额不足...");
         }
      }
   }
}

/**
 * 生产者-消费者
 * 
 * @author jianggujin
 *
 */
public class ProducConsumDemo
{
   public static void main(String[] args)
   {
      Factory factory = new Factory();
      ProductThread productThread = new ProductThread("生产工厂", factory);
      ConsumThread consumThread = new ConsumThread("消费者", factory);
      productThread.start();
      consumThread.start();
   }
}