Java多线程同步的几种方式

当多个线程同时访问一个资源时，非常容易出现安全问题。因此需要采用同步机制来解决这种问题。Java主要提供了3种实现同步机制的方法：

1）、synchronized关键字

synchronized有两种用法（synchronized方法和synchronized块）

synchronized方法。在方法的生命前加入synchronized关键字，示例如下：

public synchronized void mutithreadAccess();

synchronized块：synchronized块既可以把任意的代码声明为synchronized，也可以指定上锁的对象。有非常高的灵活性，代码如下：

synchronized(syncObject){代码块｝

2）、wait()方法和notify()方法：

当使用synchronized来修饰某个共享资源时，如果线程A1执行synchronized代码，另外一个线程A2也要同时执行同一对象的同一synchronized代码时，线程A2将要等到线程A1执行完后，才能继续执行。这种情况下可以使用wait()方法和notify()方法。

在synchronized代码被执行期间，线程可以调用对象的wait方法，释放对象锁，进入等待状态，并且可以调用notify()方法或notify()方法通知正在等待的其他线程。notify()方法仅唤醒一个线程（等待队列中的第一个线程）并允许它去获得锁，notifyAll()方法唤醒所有等待这个对象的线程并允许它们去获得锁。

 

3）、Lock

JDK5新增了Lock接口以及它的一个实现类ReentrantLock（重入锁），Lock也可以用来实现多线程同步。

 

import java.util.concurrent.locks.*;
class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;
    private Lock lock=new ReentrantLock();

    private Condition condition_pro=lock.newCondition();
    private Condition condition_con=lock.newCondition();
    public void set(String name)  throws InterruptedException
    {
        lock.lock();
        try
        {
            while(flag)
                condition_pro.await();
            this.name=name+"-----"+count++;
            System.out.println(Thread.currentThread().getName()+"------生产者-------"+this.name);
            flag=true;
            condition_con.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
    public  void out() throws InterruptedException
    {
        lock.lock();
        try
        {
            while(!flag)
                condition_con.await();
            System.out.println(Thread.currentThread().getName()+"--消费者--"+this.name);
            flag=false;
            condition_pro.signal();
        }
        finally
        {
            lock.unlock();
        }
    }
}
class Producer implements Runnable
{
    private Resource res;
    Producer(Resource res)
    {
        this.res=res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.set("++面包++");
            }
            catch (InterruptedException e)
            {
            }

        }
    }
}
class Consumer implements Runnable
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res=res;
    }
    public void run()
    {
        while(true)
        {
            try
            {
                res.out();
            }
            catch (InterruptedException e)
            {
            }
        }
    }
}
class ProducerConsumerDemo2
{
    public static void main(String[] args)
    {
        Resource res=new Resource();

        Producer pro=new Producer(res);
        Consumer con=new Consumer(res);

        Thread t1=new Thread(pro);
        Thread t2=new Thread(pro);
        Thread t3=new Thread(con);
        Thread t4=new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}