synchronized

使用synchronized实现同步有2种方式：

同步方法(静态与非静态)
同步代码块

任何Java对象均可作为锁使用，其中，使用的锁对象有以下3种：

静态同步方法中，锁是当前类的Class对象
非静态同步方法中，锁是当前对象this(调用该方法的对象)
同步代码块中，琐是手动配置的对象

同步方法

private synchronized void f()

{

    //...

}

同步代码块

private void f()

{

    synchronized(this)

    {

        //...

    }

}

Lock

Lock接口中规定了锁必须实现的一些方法

void lock()
void unlock()
boolean tryLock()
boolean tryLock(long time, TimeUnit unit)
Condition newCondition()

Lock接口的实现类有ReentarntLock和ReentrantReadWriteLock2种，它们都提供了非公平锁和公平锁2种形式。

ReentrantLock

可重入锁，线程可以重复的获取已经持有的锁。

锁中维护着一个持有计数，来追踪对lock方法的嵌套调用，每次lock计数加1,每次unlock计数减1。

只有持有计数为0时，才释放锁。

使用示例

private Lock lock=new ReentrantLock();

private void f()

{

    lock.lock();

    try

    {

        // ...

    }

    finally

    {

        lock.unlock();

    }

}

公平锁，线程调度器将优先(并不保证一定)执行等待时间最长的线程。

在创建ReentrantLock时，可以传入Boolean参数true,创建一个公平锁。

Lock fairLock=new ReentrantLock(true);

除了使用lock()获取锁外，还可以使用tryLock()尝试获取锁，如果成功，返回true，否则，返回false，并且线程可以立即离开去做其它事情。

还可以调用传入超时参数。

ReentrantReadWriteLock

可重入读写锁。如果对一个数据结构进行读操作的次数远远大于写操作的次数，就可以使用读写锁提高性能。

使用示例

private ReentrantReadWriteLock lock=new ReentrantReadWriteLock();// 创建读写锁

private Lock readLock=lock.readLock();// 读锁

private Lock writeLock=lock.writeLock();// 写锁

// 读操作加读锁

public void read()

{

    readLock.lock();

    try

    {

        // ...

    }

    finally

    {

        readLock.unlock();

    }

}

// 写操作加写锁

public void write()

{

    writeLock.lock();

    try

    {

        // ...

    }

    finally

    {

        writeLock.unlock();

    }

}

死锁

死锁问题的产生，是由于线程A和线程B互相持有对方需要获取的锁对象导致的

private static final Object lockA=new Object();

private static final Object lockB=new Object();

private void deadLock()

{

    Thread t1=new Thread(()->{

        synchronized(lockA)

        {

            sleep(1L);

            synchronized(lockB)

            {

                System.out.println("thread 1");

            }

        }

    });

    Thread t2=new Thread(()->{

        synchronized(lockB)

        {

            sleep(1L);

            synchronized(lockA)

            {

                System.out.println("thread 2");

            }

        }

    });

    t1.start();

    t2.start();

}

private void sleep(long timeout)

{

    try

    {

        TimeUnit.SECONDS.sleep(timeout);

    }

    catch(InterruptedException e)

    {

        e.printStackTrace();

    }

}

死锁问题一旦发生，程序就会挂起。所以，必须避免死锁的发生，有以下几个方式

避免在一个线程中同时获取多个锁
尝试使用定时锁(lock.tryLock(timeout))，替代普通锁机制

巴特西

Java并发编程中的锁

synchronized

Lock

ReentrantLock

ReentrantReadWriteLock

死锁

最新文章

热门文章