Java synchronized锁 String 和 Integer 会有什么问题?

1. synchronized 锁String, 非final , 如果String的value值改变了会怎么样.

2. synchronized 锁Integer, 非final, 如果Integer 值都是1 , 多个线程并发会怎么样.

3. synchronized 锁Integer, 非final, 如果Integer 值都是128 , 多个线程并发会怎么样.

1. synchronized 锁String , 如果String的value值改变了会怎么样.

String 值改变的话, 原有的锁依旧处于加锁状态. 新的线程在申请锁的时候, 会加载到新的String 值. 导致锁失效, 新的线程依旧会执行.

2. synchronized 锁两个Integer类型的lock, 每个lock有自己的线程, 如果Integer 值都是1 , 多个线程并发会怎么样.

因为Integer类中有缓存 -128 到 127 , 如果值相同, 会导致所有的线程阻塞, 顺序执行.

3. synchronized 锁Integer, 非final, 如果Integer 值都是128 , 多个线程并发会怎么样.

如果锁的值 超出 -128 ~127 的范围. 并发执行.

public class lockString01 {
    private static String lock = "lock";

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

        doRun("t1");
        doRun("t2");
        doRun("t3");
        doRun("t4");
        doRun("t5");

//        System.out.println("chang lock.....");
        lock = "new lock";
//        System.out.println("chang lock.....");
        doRun("t6");
        doRun("t7");
//        while (true) {
//            lock = UUID.randomUUID().toString();
//            try {
//                TimeUnit.SECONDS.sleep(1L);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
    }

    private static void doRun(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("thread: " + name + " start");
                    try {
                        System.out.println("thread: " + name + " sleep. lock is :" + lock);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread: " + name + " end");
                }
            }
        }).start();
    }

}

public class lockString02 {
    private static String lock = "lock";

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

        doRun("t1");
        doRun("t2");
        doRun("t3");
        doRun("t4");
        doRun("t5");
        doRun("t6");
        doRun("t7");
        while (true) {
            lock = UUID.randomUUID().toString();
        }
    }

    private static void doRun(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("thread: " + name + " start");
                    try {
                        System.out.println("thread: " + name + " sleep. lock is :" + lock);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread: " + name + " end");
                }
            }
        }).start();
    }

}

public class lockString03 {
    private static String lock = "lock";

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

        doRun("t1");
        doRun("t2");
        doRun("t3");
        doRun("t4");
        doRun("t5");
        doRun("t6");
        doRun("t7");
        while (true) {
            lock = UUID.randomUUID().toString();
        }
    }

    private static void doRun(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("thread: " + name + " start");
                    try {
                        System.out.println("thread: " + name + " sleep. lock is :" + lock);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread: " + name + " end");
                }
            }
        }).start();
        try {
            System.out.println("thread: " + name + " block 1 s.");
            TimeUnit.SECONDS.sleep(1L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

public class lockInteger01 {
    private static Integer lock = 1;

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

        doRun("t1");
        doRun("t2");
        doRun("t3");
        doRun("t4");
        doRun("t5");


        lock = 2;
        doRun("t6");
        doRun("t7");
//        while (true) {
//            lock = UUID.randomUUID().toString();
//            try {
//                TimeUnit.SECONDS.sleep(1L);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
    }

    private static void doRun(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("thread: " + name + " start");
                    try {
                        System.out.println("thread: " + name + " sleep. lock is :" + lock);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread: " + name + " end");
                }
            }
        }).start();
    }

}

public class lockInteger02 {
    private static Integer lock = 1;

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

        doRun("t1");
        doRun("t2");
        lock = 2;
        doRun("t3");
        doRun("t4");
        doRun("t5");
        doRun("t6");
        doRun("t7");
        while (true) {
            lock = new Random().nextInt();
        }
    }

    private static void doRun(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    System.out.println("thread: " + name + " start");
                    try {
                        System.out.println("thread: " + name + " sleep. lock is :" + lock);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread: " + name + " end");
                }
            }
        }).start();
    }

}

public class lockInteger03 {
    private static Integer lock01 = 1;
    private static Integer lock02 = 1;
    public static void main(String[] args) throws Exception {

        doRunByLock01("1-t1");
        doRunByLock01("1-t2");
        doRunByLock01("1-t3");
        doRunByLock01("1-t4");
        doRunByLock01("1-t5");
        doRunByLock01("1-t6");
        doRunByLock01("1-t7");


        doRunByLock02("2-t1");
        doRunByLock02("2-t2");
        doRunByLock02("2-t3");
        doRunByLock02("2-t4");
        doRunByLock02("2-t5");
        doRunByLock02("2-t6");
        doRunByLock02("2-t7");
    }

    private static void doRunByLock01(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock01) {
                    System.out.println("thread lock 01 : " + name + " start");
                    try {
                        System.out.println("thread lock 01 : " + name + " sleep. lock is :" + lock01);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread lock 01 : " + name + " end");
                }
            }
        }).start();
    }

    private static void doRunByLock02(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock02) {
                    System.out.println("thread lock 02 : " + name + " start");
                    try {
                        System.out.println("thread lock 02 : " + name + " sleep. lock is :" + lock02);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread lock 02 : " + name + " end");
                }
            }
        }).start();
    }

}

public class lockInteger04 {
    private static Integer lock01 = -129;
    private static Integer lock02 = -129;
    public static void main(String[] args) throws Exception {

        doRunByLock01("1-t1");
        doRunByLock01("1-t2");
        doRunByLock01("1-t3");
        doRunByLock01("1-t4");
        doRunByLock01("1-t5");
        doRunByLock01("1-t6");
        doRunByLock01("1-t7");


        doRunByLock02("2-t1");
        doRunByLock02("2-t2");
        doRunByLock02("2-t3");
        doRunByLock02("2-t4");
        doRunByLock02("2-t5");
        doRunByLock02("2-t6");
        doRunByLock02("2-t7");
    }

    private static void doRunByLock01(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock01) {
                    System.out.println("thread lock 01 : " + name + " start");
                    try {
                        System.out.println("thread lock 01 : " + name + " sleep. lock is :" + lock01);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread lock 01 : " + name + " end");
                }
            }
        }).start();
    }

    private static void doRunByLock02(String name) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock02) {
                    System.out.println("thread lock 02 : " + name + " start");
                    try {
                        System.out.println("thread lock 02 : " + name + " sleep. lock is :" + lock02);
                        TimeUnit.SECONDS.sleep(5L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("thread lock 02 : " + name + " end");
                }
            }
        }).start();
    }

}