线程安全

例子：

public class Test {
private static int num = 0;
public static void main(String[] args) {
    Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100000000; i++) {
                num = num + 1;
            }
        }
    });
    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100000000; i++) {
                num = num - 1;
            }
        }
    });
    System.out.println(num);
}
}

结果是？ 不是0，因为基础类型都是非线程安全的
如何解决？

方式一：syncronized

public class Test {
private static int num = 0;
public static void main(String[] args) {
    Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100000000; i++) {
                synchronized (Test.class){
                num = num + 1;
                }
            }
        }
    });
    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100000000; i++) {
                synchronized (Test.class){
                    num = num - 1;
                }
            }
        }
    });
     thread1.start();
    thread2.start();
    System.out.println(num);
  }
}

方式二： 使用Lock

public class Test {
private static int num = 0;
public static void main(String[] args) {
    Lock lock = new ReentrantLock();
    Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100000000; i++) {
                lock.lock();
                num = num + 1;
                lock.unlock();
            }
        }
    });
    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100000000; i++) {
                    lock.lock();
                    num = num - 1;
                    lock.unlock();
            }
        }
    });
    thread1.start();
    thread2.start();
    System.out.println(num);
  }
}

方式一 与 方式 二 的区别：
都保证了线程安全
syncronized属于悲观锁 lock属于乐观锁
乐观锁的性能大于悲观锁 所以在实际开发中 推荐使用 lock

方式三 使用线程安全类

public class Test {
private static AtomicInteger num = new AtomicInteger(0);
public static void main(String[] args) {
    Lock lock = new ReentrantLock();
    Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100000000; i++) {
                num.addAndGet(1);
            }
        }
    });
    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i < 100000000; i++) {
                   num.decrementAndGet();
            }
        }
    });
    thread1.start();
    thread2.start();
    System.out.println(num);
}

}

HashMap为什么线程不安全？
HashMap在动态扩容的时候会出现 死循环 ，所以不安全
线程不安全性能 > 乐观锁性能 > 悲观锁性能

解决方案：
● new HashMap（40000），给定容量大小
● new ConcurrentHashMap()
● ThreadLocal threadlocal = new ThreadLocal();
threadlocal.set(hashMap)