飞天班第3节：JUC并发编程（1）

public synchronized void start() {
  /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
  if (threadStatus != 0)
    throw new IllegalThreadStateException();

  /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
  group.add(this);

  boolean started = false;
  try {
    start0();
    started = true;
  } finally {
    try {
      if (!started) {
        group.threadStartFailed(this);
      }
    } catch (Throwable ignore) {
      /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
    }
  }
}

private native void start0();

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

// 状态标识flag
private static volatile boolean flag = true;

// 状态标识flag，原子类
private static AtomicBoolean flag = new AtomicBoolean(true);

// 设置flag的值
VisibilityDemo.flag.set(false);

// 获取flag的值
VisibilityDemo.flag.get()

synchronized (this) {
  i++;
}

import java.time.LocalDateTime;
 
 /**
  * @author ：mmzsblog
  * @description：并发中的有序性问题
  * @date ：2020年2月26日 15:22:05
  */
 public class OrderlyDemo {
 
    static int value = 1;
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 199; i++) {
            value = 1;
            flag = false;
            Thread thread1 = new DisplayThread();
            Thread thread2 = new CountThread();
            thread1.start();
            thread2.start();
            System.out.println("=========================================================");
            Thread.sleep(6000);
        }
    }

    static class DisplayThread extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " DisplayThread begin, time:" + LocalDateTime.now());
            value = 1024;
            System.out.println(Thread.currentThread().getName() + " change flag, time:" + LocalDateTime.now());
            flag = true;
            System.out.println(Thread.currentThread().getName() + " DisplayThread end, time:" + LocalDateTime.now());
        }
    }

    static class CountThread extends Thread {
        @Override
        public void run() {
            if (flag) {
                System.out.println(Thread.currentThread().getName() + " value的值是：" + value + ", time:" + LocalDateTime.now());
                System.out.println(Thread.currentThread().getName() + " CountThread flag is true,  time:" + LocalDateTime.now());
            } else {
                System.out.println(Thread.currentThread().getName() + " value的值是：" + value + ", time:" + LocalDateTime.now());
                System.out.println(Thread.currentThread().getName() + " CountThread flag is false, time:" + LocalDateTime.now());
            }
        }
    }
}

private static volatile boolean flag = false;

public synchronized void run() {
  value = 1024;flag = true;
}

readWriteLock.writeLock().lock();
try {
          value = 1024;
          flag = true;
      } finally {
          readWriteLock.writeLock().unlock();
}

private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>(){
    //初始化ThreadLocal对象connectionHolder的共享变量为Connection类型的对象
    public Connection initialValue(){
        return DriverManager.getConnection(DB_URL);  
    }
};

public static Connection getConnection(){
    //使用ThreadLocal对象的get()方法获取其共享变量
    return connectionHolder.get();
}

public class ThreadLocal<T> {
         static class ThreadLocalMap {
             /**
             * The entries in this hash map extend WeakReference, using
             * its main ref field as the key (which is always a
             * ThreadLocal object).  Note that null keys (i.e. entry.get()
             * == null) mean that the key is no longer referenced, so the
             * entry can be expunged from table.  Such entries are referred to
             * as "stale entries" in the code that follows.
             */
            static class Entry extends WeakReference<ThreadLocal<?>> {
                /** The value associated with this ThreadLocal. */
                Object value;
    
                Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
            }
         }
}

public int loadTheArk(Collection<Animal> candidates) {
    SortedSet<Animal> animals;
    int numPairs = 0;
    Animal candidate = null;
 
    // animals被封闭在方法中，不要使它们逸出！
    animals = new TreeSet<Animal>(new SpeciesGenderComparator());
    animals.addAll(candidates);
    for (Animal a : animals) {
        if (candidate == null || !candidate.isPotentialMate(a))
            candidate = a;
        else {
            ark.load(new AnimalPair(candidate, a));
            ++numPairs;
            candidate = null;
        }
    }
    return numPairs;
}

TimeUnit.SECONDS.sleep(3);

package com.coding.demo01;
// 传统的 Synchronized
// Synchronized 方法 和 Synchronized 块
/*
 * 我们的学习是基于企业级的开发进行的；
 * 1、架构：高内聚，低耦合
 * 2、套路：线程操作资源类，资源类是单独的
 */
public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        // 1、新建资源类
        Ticket ticket = new Ticket();

        // 2、线程操纵资源类
        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <=40; i++) {
                    ticket.saleTicket();
                }
            }
        },"A").start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <=40; i++) {
                    ticket.saleTicket();
                }
            }
        },"B").start();

        new Thread(new Runnable() {
            public void run() {
                for (int i = 1; i <=40; i++) {
                    ticket.saleTicket();
                }
            }
        },"C").start();
    }
}

// 单独的资源类，属性和方法！
// 这样才能实现复用！
class Ticket{
    private int number = 30;

    // 同步锁，厕所 =>close=>
    // synchronized 这是一个关键字
    public synchronized void saleTicket(){
        if (number>0){
            System.out.println(Thread.currentThread().getName() + "卖出第"+(number--)+"票，还剩:"+number);
        }
    }
}

public class Demo02 {
    public static void main(String[] args) {
        // 1、新建资源类
        Ticket2 ticket = new Ticket2();
        // 2、线程操作资源类 , 所有的函数式接口都可以用 lambda表达式简化！
        // lambda表达式 (参数)->{具体的代码}
        new Thread(()->{for (int i = 1; i <= 40 ; i++) ticket.saleTicket();},"A").start();
        new Thread(()->{for (int i = 1; i <= 40 ; i++) ticket.saleTicket();},"B").start();
        new Thread(()->{for (int i = 1; i <= 40 ; i++) ticket.saleTicket();},"C").start();

    }
}

// 依旧是一个资源类
class Ticket2{
    // 使用Lock，它是一个对象
    // ReentrantLock 可重入锁：回家：大门 (卧室门，厕所门...)
    // ReentrantLock 默认是非公平锁！
    // 非公平锁: 不公平 （插队，后面的线程可以插队）
    // 公平锁: 公平（只能排队，后面的线程无法插队）
    private Lock lock = new ReentrantLock();
    private int number = 30;

    public void saleTicket(){
        lock.lock(); // 加锁
        try {
            // 业务代码
            if (number>0){
                System.out.println(Thread.currentThread().getName() + "卖出第"+(number--)+"票，还剩:"+number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 解锁
        }
    }
}

/*
目的：有两个线程：A  B ，还有一个值初始为0，
     实现两个线程交替执行，对该变量 + 1，-1；交替10次
 */
public class Demo03 {
    public static void main(String[] args) {
        Data data = new Data();

        // +1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        // -1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}

// 资源类
// 线程之间的通信： 判断  执行  通知
class Data{
    private int number = 0;
    // +1
    public synchronized void increment() throws InterruptedException {
        if (number!=0){ // 判断是否需要等待
            this.wait(); // 当前线程等待，释放锁，直到另外一个线程调用该对象的notify()或notifyAll()方法
        }
        number++; // 执行
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll(); //唤醒所有线程
    }

    // -1
    public synchronized void decrement() throws InterruptedException {
        if (number==0){ // 判断是否需要等待
            this.wait(); // 等待，释放锁
        }
        number--; // 执行
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        // 通知
        this.notifyAll(); //唤醒所有线程
    }
}

public class Demo04 {
    public static void main(String[] args) {
        Data04 data = new Data04();

        // +1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        // +1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
      
       // -1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        // -1
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}

class Data04{
	private int number = 0;
	// +1
	public synchronized void increment() throws InterruptedException {
		 if (number!=0){ // 判断是否需要等待
			this.wait();
		}
		number++; // 执行
		System.out.println(Thread.currentThread().getName()+"\t"+number);
		// 通知
		this.notifyAll(); //唤醒所有线程
	}

	// -1
	public synchronized void decrement() throws InterruptedException {
		if (number==0){ // 判断是否需要等待
			this.wait();
		}
		number--; // 执行
		System.out.println(Thread.currentThread().getName()+"\t"+number);
		// 通知
		this.notifyAll(); //唤醒所有线程
	}
}

// 修改Data，使用while代替if，解决虚假唤醒问题
class Data04{
	private int number = 0;
	// +1
	public synchronized void increment() throws InterruptedException {
		 while(number!=0){ // 判断是否需要等待
			this.wait(); 
		}
		number++; // 执行
		System.out.println(Thread.currentThread().getName()+"\t"+number);
		// 通知
		this.notifyAll(); //唤醒所有线程
	}

	// -1
	public synchronized void decrement() throws InterruptedException {
		while (number==0){ // 判断是否需要等待
			this.wait();
		}
		number--; // 执行
		System.out.println(Thread.currentThread().getName()+"\t"+number);
		// 通知
		this.notifyAll(); //唤醒所有线程
	}
}

package com.coding.demo01;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
实现线程交替执行！
主要的实现目标：精准的唤醒线程！
    三个线程：A B C
    三个方法：A p5  B p10  C p15 依次循环
 */
public class Demo05 {
    public static void main(String[] args) {
        Data05 data = new Data05();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.print5();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.print10();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new Thread(()->{
            for (int i = 1; i <= 10; i++) {
                try {
                    data.print15();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
    }
}

// 资源类
class Data05{
    private int number = 1; // 1A 2B  3C
    // 一把锁
    private Lock lock = new ReentrantLock();
    // 实现精准访问
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void print5() throws InterruptedException {
        lock.lock();
        try {
            // 判断
            while (number!=1){
                condition1.await();
            }
            // 执行
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            // 通知第二个线程干活！
            number = 2;
            condition2.signal(); // 唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); // 一定要解锁
        }
    }

    public void print10() throws InterruptedException {
        lock.lock();
        try {
            // 判断
            while (number!=2){
                condition2.await();
            }
            // 执行
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            // 通知3干活
            number = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print15() throws InterruptedException {
        lock.lock();
        try {
            // 判断
            while (number!=3){
                condition3.await();
            }
            // 执行
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            // 通知 1 干活
            number = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

/**
1、标准的访问情况下，先执行 sendEmail 还是 sendSMS

   答案：sendEmail
   被 synchronized 修饰的方式，锁的对象是方法的调用者，所以说这里两个方法调用的对象是同一个
   先调用的先执行！
 */
public class LockDemo1 {
	public static void main(String[] args) throws InterruptedException {
		Phone phone = new Phone();

		new Thread(() -> {
			phone.sendEmail();
		},"A").start();

		TimeUnit.SECONDS.sleep(2);

		new Thread(() -> {
			phone.sendSMS();
		},"B").start();

	}

}

class Phone {
	public synchronized void sendEmail() {
		System.out.println("sendEmail");
	}

	public synchronized void sendSMS() {
		System.out.println("sendSms");
	}
}

/**
 * 2、sendEmail休眠3秒后 ，先执行 sendEmail 还是 sendSMS
 
 * 答案：sendEmail
 *    被 synchronized 修饰的方式，锁的对象是方法的调用者，所以说这里两个方法调用的对象是同一个
 *    先调用的先执行！
 */
public class LockDemo2 {
	public static void main(String[] args) throws InterruptedException {
		Phone2 phone = new Phone2();

		new Thread(() -> {
			try {
				phone.sendEmail();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		},"A").start();

		TimeUnit.SECONDS.sleep(2);

		new Thread(() -> {
			phone.sendSMS();
		},"B").start();

	}
}

class Phone2 {
	public synchronized void sendEmail() throws InterruptedException {
		TimeUnit.SECONDS.sleep(3);
		System.out.println("sendEmail");
	}

	public synchronized void sendSMS() {
		System.out.println("sendSms");
	}
}

/**
 * 3、一个普通方法，一个synchronized 修饰的方法，先执行sendEmail还是sendSMS
 *
 * 答案：sendSMS
 * sendSMS方法没有synchronized 修饰，不是同步方法，不受锁影响
 */
public class LockDemo3 {
	public static void main(String[] args) throws InterruptedException {
		Phone3 phone = new Phone3();

		new Thread(() -> {
			try {
				phone.sendEmail();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		},"A").start();

		TimeUnit.SECONDS.sleep(2);

		new Thread(() -> {
			phone.sendSMS();
		},"B").start();

	}
}

class Phone3 {
	public synchronized void sendEmail() throws InterruptedException {
		TimeUnit.SECONDS.sleep(3);
		System.out.println("sendEmail");
	}

	public  void sendSMS() {
		System.out.println("sendSms");
	}
}

/**
 * 4、两个手机，请问先执行sendEmail 还是 sendSMS
*   答案：sendSMS
 *  被 synchronized 修饰的方法，锁的对象是调用者；我们这里有两个调用者，两个方法在这里是两个锁
 */
public class LockDemo4 {
	public static void main(String[] args) throws InterruptedException {
		Phone4 phone1 = new Phone4();
		Phone4 phone2 = new Phone4();

		new Thread(() -> {
			try {
				phone1.sendEmail();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		},"A").start();

		TimeUnit.SECONDS.sleep(1);

		new Thread(() -> {
			phone2.sendSMS();
		},"B").start();

	}
}

class Phone4 {
	public synchronized void sendEmail() throws InterruptedException {
		TimeUnit.SECONDS.sleep(3);
		System.out.println("sendEmail");
	}

	public synchronized void sendSMS() {
		System.out.println("sendSms");
	}
}

/**
 * 5、两个静态同步方法，同一个手机访问，先执行sendEmail还是sendSMS
 *
 * 答案：sendEmail
 * 方法被static 修饰，synchronized 锁的对象的Class 类模版，这个全局唯一，所以说这里说同一个锁
 */
public class LockDemo5 {
	public static void main(String[] args) throws InterruptedException {
		Phone5 phone = new Phone5();

		new Thread(() -> {
			try {
				phone.sendEmail();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		},"A").start();

		TimeUnit.SECONDS.sleep(1);

		new Thread(() -> {
			phone.sendSMS();
		},"B").start();

	}

}

class Phone5 {
	public static synchronized void sendEmail() throws InterruptedException {
		TimeUnit.SECONDS.sleep(3);
		System.out.println("sendEmail");
	}

	public static synchronized void sendSMS() {
		System.out.println("sendSMS");
	}
}

/**
 * 6、两个静态同步方法，两个手机访问，先执行sendEmail，还是sendSMS
 *
 * 答案：sendEmail
 * 只要方法被static修饰，synchronized锁的对象锁Class类模版，全局唯一，所以说这里是同一个锁，谁先获取谁先执行，执行完毕才释放锁
 *
 */
public class LockDemo6 {

	public static void main(String[] args) throws InterruptedException {
		Phone6 phone1 = new Phone6();
		Phone6 phone2 = new Phone6();

		new Thread(() -> {
			try {
				phone1.sendEmail();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();

		TimeUnit.SECONDS.sleep(1);

		new Thread(() -> {
			phone2.sendSMS();
		}).start();
	}
}

class Phone6 {
	public static synchronized void sendEmail() throws InterruptedException {
		TimeUnit.SECONDS.sleep(3);
		System.out.println("sendEmail");
	}

	public static synchronized void sendSMS() {
		System.out.println("sendSMS");
	}
}

/**
 * 7、一个静态同步方法，一个普通同步方法，只有一个手机，先执行sendEmail还是sendSMS
 * 答案：sendSMS
 * 静态同步方法，锁的是Class类模版
 * 普通同步方法，锁的是方法调用的对象
 * 这里是两个不同的锁
 */
public class LockDemo7 {
	public static void main(String[] args) throws InterruptedException {
		Phone7 phone = new Phone7();

		new Thread(() -> {
			try {
				phone.sendEmail();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();

		TimeUnit.SECONDS.sleep(1);

		new Thread(() -> {
			phone.sendSMS();
		}).start();
	}
}

class Phone7 {
	public static synchronized void sendEmail() throws InterruptedException {
		TimeUnit.SECONDS.sleep(3);
		System.out.println("sendEmail");
	}

	public  synchronized void sendSMS() {
		System.out.println("sendSMS");
	}
}

/**
 * 8、一个静态同步方法，一个普通同步方法，两个手机，先输出sendEmail还是sendSMS
 * 答案：sendSMS
 * 静态同步方法，锁的是Class类模版
 * 普通同步方法，锁的是方法调用的对象
 * 这里是两个不同的锁
 */
public class LockDemo8 {
	public static void main(String[] args) throws InterruptedException {
		Phone8 phone1 = new Phone8();
		Phone8 phone2 = new Phone8();


		new Thread(() -> {
			try {
				phone1.sendEmail();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();

		TimeUnit.SECONDS.sleep(1);

		new Thread(() -> {
			phone2.sendSMS();
		}).start();
	}
}

class Phone8 {
	public static synchronized void sendEmail() throws InterruptedException {
		TimeUnit.SECONDS.sleep(3);
		System.out.println("sendEmail");
	}

	public  synchronized void sendSMS() {
		System.out.println("sendSMS");
	}
}

public class UnsafeList {
	public static void main(String[] args) {
		List<String> list = new ArrayList<>();

		for (int i = 0; i < 10; i++) {
			new Thread(() -> {
				list.add(UUID.randomUUID().toString().substring(0,3));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}

public class UnsafeList {
	public static void main(String[] args) {
		List<String> list = new Vector<>();

		for (int i = 0; i < 30; i++) {
			new Thread(() -> {
				list.add(UUID.randomUUID().toString().substring(0,3));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}

public class UnsafeList {
	public static void main(String[] args) {
		/// List<String> list = new Vector<>(); Jdk1.0就存在，效率低
		List<String> list = Collections.synchronizedList(new ArrayList<>());
		for (int i = 0; i < 30; i++) {
			new Thread(() -> {
				list.add(UUID.randomUUID().toString().substring(0,3));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}

public class UnsafeList {
	public static void main(String[] args) {
		/// List<String> list = new Vector<>(); Jdk1.0就存在，效率低

		//List<String> list = Collections.synchronizedList(new ArrayList<>())

		List<String> list = new CopyOnWriteArrayList<>();
		for (int i = 0; i < 30; i++) {
			new Thread(() -> {
				list.add(UUID.randomUUID().toString().substring(0,3));
				System.out.println(list);
			},String.valueOf(i)).start();
		}
	}
}

public class UnsafeSet {
	public static void main(String[] args) {
		// HashSet 底层是什么，点击源码它是一个new HashMap()
		Set<String> set = new HashSet<>();

		for (int i = 0; i <30 ; i++) {
			new Thread(() -> {
				set.add(UUID.randomUUID().toString().substring(0,3));
				System.out.println(set);
			}).start();
		}
	}
}

public class UnsafeSet {
	public static void main(String[] args) {
		// HashSet 底层是什么，点击源码它是一个new HashMap()
		//Set<String> set = new HashSet<>();
		Set<String> set = Collections.synchronizedSet(new HashSet<>());
		for (int i = 0; i <30 ; i++) {
			new Thread(() -> {
				set.add(UUID.randomUUID().toString().substring(0,3));
				System.out.println(set);
			}).start();
		}
	}
}

public class UnsafeSet {
	public static void main(String[] args) {
		// HashSet 底层是什么，点击源码它是一个new HashMap()
		//Set<String> set = new HashSet<>();
		//Set<String> set = Collections.synchronizedSet(new HashSet<>());
		Set<String> set = new CopyOnWriteArraySet<>();

		for (int i = 0; i <30 ; i++) {
			new Thread(() -> {
				set.add(UUID.randomUUID().toString().substring(0,3));
				System.out.println(set);
			}).start();
		}
	}
}

// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();

/**
 * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
 * default initial capacity (16) and load factor (0.75).
 */
public HashSet() {
  map = new HashMap<>();
}

public boolean add(E e) {
  return map.put(e, PRESENT)==null;
}

public static void main(String[] args) {
  // new HashMap(),工作中不能这样用
  // 因为默认容量是16，扩展容量是损耗性能的，所以应该确认初始化的容量
  // HashMap的底层数据结构 链表+红黑树

  Map<String,String> map = new HashMap<>(30);
  for (int i = 0; i <30 ; i++) {
    new Thread(() -> {
      map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,3));
      System.out.println(map);
    }).start();
  }
}
}

public static void main(String[] args) {
  Map<String,String> map =new ConcurrentHashMap <>(30);
  for (int i = 0; i <30 ; i++) {
    new Thread(() -> {
      map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,3));
      System.out.println(map);
    }).start();
  }
}

void transfer(Entry[] newTable, boolean rehash) {  
  int newCapacity = newTable.length;  
  for (Entry<K,V> e : table) {  

    while(null != e) {  
      Entry<K,V> next = e.next;           
      if (rehash) {  
        e.hash = null == e.key ? 0 : hash(e.key);  
      }  
      int i = indexFor(e.hash, newCapacity);   
      e.next = newTable[i];  
      newTable[i] = e;  // 线程 A 运行到这里时被挂起
      e = next;  
    } 
  }  
}  

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
  Node<K,V>[] tab; Node<K,V> p; int n, i;
  if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;
  if ((p = tab[i = (n - 1) & hash]) == null)     // 如果没有 hash 碰撞，则直接插入
    tab[i] = newNode(hash, key, value, null);