synchronized和lock实现线程同步

线程的生命周期包含5个阶段，包括：新建、就绪、运行、阻塞、销毁。

• 新建：就是刚使用new方法，new出来的线程；

• 就绪：就是调用的线程的start()方法后，这时候线程处于等待CPU分配资源阶段，谁先抢的CPU资源，谁开始执行;

• 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能;

• 阻塞：在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态，比如sleep()、wait()之后线程就处于了阻塞状态，这个时候需要其他机制将处于阻塞状态的线程唤醒，比如调用notify或者notifyAll()方法。唤醒的线程不会立刻执行run方法，它们要再次等待CPU分配资源进入运行状态;

• 销毁：如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束，那么线程就要被销毁，释放资源;

完整的生命周期图如下：

                                

什么是线程同步？

线程同步 ，线程同步其实并不是真正意义上的同步，通常我们理解的同步，一般都是步调一致，同时进行的操作（比如，大阅兵时，三军将士保持整齐的队列，在威武雄壮的进行曲中迈出相同的步伐，即步调一致）；

而这里的“ 同步 ” 其实是协同各个线程，按照顺序一个一个地执行，即协同步调。

了解了这些概念，再来看synchronized和lock是怎样实现线程同步的，也许对线程同步就有了更深刻的理解。

1. synchronized 实现线程同步

public class MyThread implements Runnable {

    private Integer tickets = 10;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + "还剩" + tickets + "张票");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    tickets--;
                }
            }
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        for (int i = 1; i < 10; i++) {
            new Thread(myThread, "窗口" + i).start();
        }
    }

}

执行结果如下：

因卖票是线程同步的，各个窗口并没有出现卖同一张票的情况。

2. lock 实现线程同步

public class MyThread implements Runnable {

    private Integer tickets = 10;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + "还剩" + tickets + "张票");
                    Thread.sleep(100);
                    tickets--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        for (int i = 1; i < 10; i++) {
            new Thread(myThread, "窗口" + i).start();
        }
    }

}

执行结果如下：同样达到了线程同步的效果

  再简单说下lock和synchronized的区别：

（1）lock是一个接口，而synchronized是java的关键字，synchronized是内置的语言实现；

（2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而lock在发生异常时，如果没有主动通过unlock（）去释放锁，则很可能造成死锁现象，因此使用lock（）时需要在finally块中释放锁；

（3）lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去；

（4）通过lock可以知道有没有成功获取锁，而synchronized却无法办到 ( 可以判断锁的状态 )；

  (5)  lock可定时的、可轮询的与可中断的锁获取操作，提供了读写锁、公平锁和非公平锁;

 在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而竞争资源非常激烈是（既有大量线程同时竞争），此时lock的性能要远优于synchronized。所以说，在具体使用时适当情况选择。

 与大家共勉！！！