Java多线程 park和unpark实现生产者和消费者

LockSupport的park和unpark实现挂起和唤醒线程
相比wait和notify方法.park和unpark使用没有要求先执行prak后执行unpark的顺序,他们执行顺序不会导致死锁.
但是他们在synchronized关键字包围的方法里面,他们还是会导致死锁,因为他们执行好不释放锁.
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.LockSupport;

public class ParkAndUnParkTest {
    public static void main(String[] args) {
        final List<Object> list = new ArrayList<>();
        final int maxSize = 10;
        List<Thread> consumers = new ArrayList<>();
        List<Thread> providers = new ArrayList<>();
        Provider p = new Provider(list, maxSize);
        Provider p2 = new Provider(list, maxSize);
        Consumer c = new Consumer(list, maxSize);
        Consumer c2 = new Consumer(list, maxSize);
        consumers.add(p);
        consumers.add(p2);
        providers.add(c);
        providers.add(c2);
        p.start();
        p2.start();
        c.start();
        c2.start();

    }
}

class Provider extends Thread{
    private List<Thread> consumers;
    private List<Object> list;
    private int maxSize;
    public Provider(List<Object> list,int maxSize){
        this.list = list;
        this.maxSize = maxSize;
    }
    public List<Thread> getConsumers() {
        return consumers;
    }

    public void setConsumers(List<Thread> consumers) {
        this.consumers = consumers;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产者开始"+list.size());
            while (list.size() == maxSize){
                LockSupport.park();
            }
            System.out.println("生产了一个");
            list.add(new Object());
            if (consumers != null && consumers.size() > 0){
                for (Thread consumer : consumers){
                    LockSupport.unpark(consumer);
                }
            }
        }
    }
}
class Consumer extends Thread{
    private List<Thread> providers;
    private List<Object> list;
    private int maxSize;
    public Consumer(List<Object> list,int maxSize){
        this.list = list;
        this.maxSize = maxSize;
    }
    public List<Thread> getProviders() {
        return providers;
    }

    public void setProviders(List<Thread> providers) {
        this.providers = providers;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("消费者开始"+list.size());
            while (list.size() == 0){
                LockSupport.park();
            }
            System.out.println("消费了一个");
            list.remove(list.size()-1);
            if (providers != null && providers.size() > 0){
                for (Thread provider : providers){
                    LockSupport.unpark(provider);
                }
            }
        }
    }
}