java中线程同步方法

基本概念

共享变量

共享变量必须要保证线程安全，对于共享变量复合操作，保证复合操作的线程安全性。

线程通信协作的最常见方式

• syncrhoized加锁的线程的Object类的wait()/notify()/notifyAll()
• ReentrantLock类加锁的线程的Condition类的await()/signal()/signalAll()

线程同步

一个线程对共享数据的操作应该具有原子性，在对共享数据进行操作没有完成操作之前，其他线程不允许打断该线程的操作，不能使共享数据的完整性得到破坏。
实现线程同步的方法：

• 同步代码方法：sychronized 关键字修饰的方法
• 同步代码块：sychronized 关键字修饰的代码块
• 使用特殊变量域volatile实现线程同步：volatile关键字为域变量的访问提供了一种免锁机制
• 使用重入锁实现线程同步：reentrantlock类是可冲入、互斥、实现了lock接口的锁他与sychronized方法具有相同的基本行为和语义

线程互斥

对于共享的资源，只允许一个线程访问，其他线程不能进行访问，如果多个线程要使用使用该资源的线程必须等待，直到占用资源者释放该资源。

多线程安全

使用synchronized关键字

同步方法块：

public class SyncronizedDemo implements Runnable {

    private int count = 5;

    @Override
    public synchronized void run() {
        count--;
        System.out.println(Thread.currentThread().getName()+" count = "+count );
    }

    public static void main(String[] args) {
        //创建
        SyncronizedDemo thread = new SyncronizedDemo();
        for(int i = 0 ; i < 5 ;i++){
            new Thread(thread).start();
        }
    }
}

同步代码块

/**
 * synchronized实现线程输出
 */
public class SyncronizedDemo implements Runnable {

    private int count = 5;

    private final Object o = new Object();

    /*@Override
    public synchronized void run() {
        count--;
        System.out.println(Thread.currentThread().getName()+" count = "+count );
    }*/

    @Override
    public void run() {
        synchronized (o) {
            count--;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
    public static void main(String[] args) {
        //创建
        SyncronizedDemo thread = new SyncronizedDemo();
        for(int i = 0 ; i < 5 ;i++){
            new Thread(thread).start();
        }
    }
}

输出结果：

Thread-0 count = 4
Thread-4 count = 3
Thread-3 count = 2
Thread-2 count = 1
Thread-1 count = 0

使用并发包下的类实现同步

AtomicInteger，AtomicBoolean,AtomicLong等

/**
 * synchronized实现线程输出
 */
public class SyncronizedDemo implements Runnable {
    private AtomicInteger count = new AtomicInteger(5);
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " count = " + count.decrementAndGet());
    }
    public static void main(String[] args) {
        //创建
        SyncronizedDemo thread = new SyncronizedDemo();
        for(int i = 0 ; i < 5 ;i++){
            new Thread(thread).start();
        }
    }
}

使用Lock来实现

public class Lock implements Runnable{

    private int count = 5;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        lock. lock();
        try {
            System.out.println(Thread.currentThread().getName()+"获得锁 :Count = "+count--);
        } catch (Exception e) {
           e.printStackTrace();
        } finally {
            System. out. println(Thread.currentThread().getName()+"释放锁");
            lock. unlock();
        }

    }
    public static void main(String[] args) {
        Lock thread = new Lock();
        for(int i = 0 ; i < 5 ;i++){
            new Thread(thread).start();
        }
    }
}

打印输出：

Thread-0获得锁 :Count = 5
Thread-0释放锁
Thread-1获得锁 :Count = 4
Thread-1释放锁
Thread-2获得锁 :Count = 3
Thread-2释放锁
Thread-3获得锁 :Count = 2
Thread-3释放锁
Thread-4获得锁 :Count = 1
Thread-4释放锁