java多线程：5.2 synchronized锁

synchronized

商品说到锁的种类中，提到synchronized加锁机制。前面通过线程间的通信，我们提到过，当线程wait和notify时，需要获取该对象的监视器，而获取监视器的操作就是synchronized，其实synchronized获取的监视器也可以看做锁，其实线程间的通信也是可以看做，多线程访问统一资源，即：访问一个变量，表明可以执行了。
通过synchronized解决System.out的问题。

public class SynchronizedTest {
    public static final Object lock = new Object();
    public static void main(String[] args) {
        final String name = "xiaoming";
        new Thread(new Runnable() {
            @Override
            public void run() {
                String[] arr = name.split("");
                while(true){
                    synchronized (lock){
                        for(int i = 0; i< arr.length;i++){
                            System.out.print(arr[i]);
                        }
                        System.out.println();
                    }
                }
            }
        },"小明").start();
        while(true) {
            synchronized (lock) {
                System.out.println("this is "+Thread.currentThread().getName());
            }
        }
    }
}

synchronized实现消费者和生产者

说明：为了方便测试，生产者和消费者都是一次操作就结束了，而不是循环的生产消费。

public class SynchronizedProduceAndCustomer {
    public static void main(String[] args) {
        final Factory fac = new Factory(3);
        // 批量生产者
        for(int i=0;i<10;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    String prodcut = "产品："+new Random().nextInt(100);
                    fac.produce(prodcut);
                    System.out.println("生产："+prodcut);
                }
            },"生产者").start();
        }
        // 批量消费者
        for(int i=0;i<20;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("消费："+fac.consume());
                }
            },"生产者").start();
        }
    }
}

/**生产者和消费者的共同资源就是工厂，因此需要对工厂进行加锁*/
class Factory{
    /**物资存放*/
    private List<String> list = new ArrayList<>();
    /**工厂可以存储的商品数量*/
    private Integer num;
    private final Object lock = new Object();

    public Factory(Integer num){
        this.num = num;
    }

    public void produce(String product){
        synchronized (lock){
            while(list.size() == num){
                // 物资已经满了
                System.out.println(Thread.currentThread().getName()+"：物资满了，"+allProduct());
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 还有空缺
            list.add(product);
        }
    }

    public String consume(){
        synchronized (lock){
            while(list.size() == 0){
                // 没有物资了
                System.out.println(Thread.currentThread().getName()+" 没有物资了");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 还有物资
            String product = list.remove(0);
            lock.notifyAll();
            return  product;
        }
    }

    private String allProduct(){
        if(!CollectionUtils.isEmpty(list)){
            StringBuilder sb = new StringBuilder();
            for (String s : list) {
                sb.append(","+s);
            }
            return sb.substring(1);
        }
        return "";
    }
}

总结

synchronized的用法：
1 synchronized java关键字，jvm层面，通过底层进行控制，这块具体如何控制，就不在本篇文章讨论。
2 synchronized 获取锁的线程，执行完同步代码后就会释放锁，同时如果同步代码发生异常，那么也会释放锁，这些都是jvm层面负责，我们不用关心，加锁是synchronized最常用的方式。
3 A、B两个线程同时获取锁，A获取锁后，B就只能等待A释放锁:(1) A执行完同步代码块，(2) A的同步代码块出异常了，(3) A调用锁对象的wait方法，主动等待，释放锁。
4 无法知道当前锁的使用情况：是否被使用。
5 synchronized 可以重入，即当前线程获取锁后，再次获取锁是允许的(方法的递归调用同步代码)，不可以打断(线程在等待锁的过程中，不能被打断)，非公平(谁抢到算谁的)。
6 当发生死锁时，可以通过监控工具监控synchronized的锁定情况，看看是因为什么产生了死锁。
7 synchronized可以结合wait，notify(),notifyAll()，实现一些特殊的业务逻辑。