juc--8锁现象、不安全集合与map类

juc–8锁现象、不安全集合与map类

8锁现象

package com.zy.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁：就是关于锁的8个问题
 * 1.标准情况下，两个线程先打印发短信还是打电话？ 发短信>打电话
 * 2.sendMsn延迟4秒，两个线程先打印发短信还是打电话？ 发短信>打电话
 * @program: JucPro
 * @author: zy
 * @create: 2023-04-18 20:57
 */
public class Demo01 {

    public static void main(String[] args) throws InterruptedException {

        Phone phone = new Phone();

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

        TimeUnit.SECONDS.sleep(1);

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

    }
}

class Phone{

    /*
        1.synchronized 锁的对象是方法的调用者，两个方法用的是同一把锁，谁先拿到谁先执行；
     */

    public synchronized void sendMsn(){
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
}

package com.zy.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁：就是关于锁的8个问题
 * 3.增加了一个普通方法，先执行发短信还是hello？   hello>发短信
 * 4.增加了一个对象，先执行发短信还是打电话？   打电话>发短信
 * @program: JucPro
 * @author: zy
 * @create: 2023-04-18 20:57
 */
public class Demo02 {

    public static void main(String[] args) throws InterruptedException {

        // 两个对象，两个调用者，两把锁
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

        new Thread(()->{phone1.sendMsn();},"A").start();

        TimeUnit.SECONDS.sleep(1);

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

    }
}

class Phone2{

    public synchronized void sendMsn(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }

    // 这里没有锁，不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }

}

package com.zy.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁：就是关于锁的8个问题
 * 5.增加两个静态同步方法，只有一个对象，先执行打电话还是发短信？    发短信>打电话
 * 6.两个对象，两个静态同步方法，先执行打电话还是发短信？ 发短信>打电话
 * @program: JucPro
 * @author: zy
 * @create: 2023-04-18 21:16
 */
public class Demo03 {

    public static void main(String[] args) throws InterruptedException {

        // 两个对象的Class类模板只有一个，static锁的是Class
        Phone3 phone3 = new Phone3();
        Phone3 phone4 = new Phone3();

        new Thread(()->{Phone3.sendMsn();},"A").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{Phone3.call();},"B").start();

    }
}

// 唯一的Class对象
class Phone3{

    // static 静态方法，类一加载就有了，Class模板，锁的是Class模板
    public static synchronized void sendMsn(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call(){
        System.out.println("打电话");
    }

}

package com.zy.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 8锁：就是关于锁的8个问题
 * 7.一个静态同步方法，一个普通同步方法，一个对象，先执行打电话还是发短信？    打电话>发短信
 * 8.一个静态同步方法，一个普通同步方法，两个对象，先执行打电话还是发短信？    打电话>发短信
 * @program: JucPro
 * @author: zy
 * @create: 2023-04-18 21:24
 */
public class Demo04 {

    /*
        new this 具体的一个手机;
        static Class 唯一的一个模板；
     */

    public static void main(String[] args) throws InterruptedException {

        Phone4 phone = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{Phone4.sendMsn();},"A").start();

        TimeUnit.SECONDS.sleep(1);

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

    }
}

// 唯一的Class对象
class Phone4 {

    // 静态同步方法：锁的是Class类模板
    public static synchronized void sendMsn(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    // 普通同步方法：锁的是方法调用者对象
    public synchronized void call(){
        System.out.println("打电话");
    }

}

多线程下不安全List类

package com.zy.unsafe;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 不安全集合类
 * @program: JucPro
 * @author: zy
 * @create: 2023-04-18 21:32
 */
public class UnsafeList {

    /*
    java.util.ConcurrentModificationException：并发修改异常！
     */

    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "3");
        list.forEach(System.out::println);

        // 并发下，ArrayList 不安全
        /*
        解决方案：
            1. Vector：List<String> list1 = new Vector<>();
            2. Collections.synchronizedList(new ArrayList<>());
            3. juc：List<String> list1 = new CopyOnWriteArrayList<>();
                CopyOnWrite：写入时复制，COW，计算机程序设计领域的一种优化策略；
                多个线程调用时，list，读取时固定，写入时复制写入保证唯一性
                写入时避免覆盖，造成数据不一致
                CopyOnWriteArrayList 比较 Vector：
                    vector底层上的add方法附加了synchronized关键字
                    CopyOnWriteArrayList底层上的add方法中用了lock可重入锁
         */
        //List<String> list1 = new ArrayList<>();
        //List<String> list1 = Collections.synchronizedList(new ArrayList<>());
        List<String> list1 = new CopyOnWriteArrayList<>();
        //List<String> list1 = new Vector<>();

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

不安全Set类

package com.zy.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * 不安全Set类
 * @program: JucPro
 * @author: zy
 * @create: 2023-04-18 22:03
 */
public class UnsafeSet {

    public static void main(String[] args) {

        // 并发下，Set 不安全
        /*
        public HashSet() {
            map = new HashMap<>();
        }
        public boolean add(E e) {
            return map.put(e, PRESENT)==null;
        }
        private static final Object PRESENT = new Object();常量不可变
        Set本质就是map key是无法重复的！
        解决方案：
            1. Set<String> set = Collections.synchronizedSet(new HashSet<>());
            2. juc：Set<String> set = new CopyOnWriteArraySet<>();
         */
        //Set<String> set = new HashSet<>();
        //Set<String> set = Collections.synchronizedSet(new HashSet<>());
        Set<String> set = new CopyOnWriteArraySet<>();

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

不安全Map

package com.zy.unsafe;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 不安全Map
 * @program: JucPro
 * @author: zy
 * @create: 2023-04-18 22:14
 */
public class UnsafeMap {

    public static void main(String[] args) {
        // 加载因子，初始化容量
        // map是这样用的吗？不是，工作中不用HashMap
        // 默认等价于什么？new HashMap<String, String>(16,0.75f);
        //Map<String, String> map = new HashMap<>();

        /*
        解决方案：
            1. Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
            2. juc：Map<String, String> map = new ConcurrentHashMap<>();
         */
        //Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
        Map<String, String> map = new ConcurrentHashMap<>();

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