并发编程-同步与锁

概念

在并发编程开发过程中，如果多个线程共享一块资源，就会产生竞争条件，考虑安全性，需要同步机制保证代码能够正确执行，保证任何时刻，只能有一个线程占有锁和执行同步代码块，没有获取到锁的线程存放在等待队列中。

实现方式

• synchronized关键字修饰需要同步的方法和对象
• Lock锁机制实现同步
• 原子变量实现同步

synchronized

可以作为修饰符，也可以作为语句，即可以同步代码块，也可以同步方法。但获得的都是对象锁，每个对象只能有一个锁。

案例

//共享对象
public class Synch {
     int count = 0;

    public  void increse() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(1000);
        count++;
        System.out.println(count);
    }
}
//调用
public class SynchDemo {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        Synch synch = new Synch();
        for(int i=0;i<10;i++){
            executorService.execute(()->{
                try {
                    synch.increse();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
    }
}

Synch类没有加synchronized修饰时,返回的结果为

A6E2E747-DD8D-4F44-B594-560D3CD365DC.png

Synch类加synchronized修饰时,返回的结果为

5A443BCB-67CF-434D-8E2C-1809E22D4B04.png

public class LockSynch {

    private AtomicInteger increase = new AtomicInteger(0);

    private ReentrantLock lock = new ReentrantLock();

    public void increase()  {
        try {
            //lock.lock();
            Thread.sleep(1000);
            int number = increase.incrementAndGet();
            System.out.println(number);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //lock.unlock();
        }

    }
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        LockSynch lockSynch = new LockSynch();
        for(int i=0;i<10;i++){
            executorService.execute(new Runnable(){
                @Override
                public void run() {
                    lockSynch.increase();
                }
            });
        }
    }
}

注：通过原子变量保证线程同步，但不保证线程的执行顺序。