JUC（自用）【未完成】_鲤鱼非鱼的博客-程序员宅基地

技术标签： JAVA java 多线程并发编程

JUC

java.util.concurrent

多线程

线程和进程

Java默认两个线程
- main
- GC

Java本身不可以开启线程

并发和并行

并发
- 单核CPU,模拟出多条线程,快速交替
并行
- 多核CPU,多条线程同时进行

并发编程的原因:充分利用CPU资源

获取当前核数

Runtime.getRuntime().availableProcessors();

线程的状态

6个

NEW:新生
RUNNABLE:运行
BLOCKED:阻塞
WAITING:等待
TIMED_WATITING:超时等待
TERMINATED:终止

wait/sleep

wait	sleep
属于Object	属于Thread
会释放锁	不释放锁
在同步代码块中	在任意地方

java.util.concurrent.locks

LOCK & synchronized

lock和synchronized的区别

synchronized lock

内置关键字 Java类

无法判断锁可判断锁

自动释放锁手动释放锁

可重入锁,非公平可重入锁,公平/非公平

适合少量代码适合大量代码

synchronized	lock
内置关键字	Java类
无法判断锁	可判断锁
自动释放锁	手动释放锁
可重入锁,非公平	可重入锁,公平/非公平
适合少量代码	适合大量代码

lock java.util.concurrent.locks
- ReentrantLock:可重入锁
- ReentrantReadWriteLock.ReadLock:读锁
- ReentrantReadWriteLock.WriteLock:写锁
lock三部曲
1. new ReentrantLock();
2. lock.lock()
3. finally=>lock.unlock()

Condition & 生产者/消费者

synchroniazed	Lock
wait	Condition.await
notify	Condition.signal

synchronized版

用if可能产生虚假唤醒情况,判断等待应写在while循环中
用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。
```
class Data{
      
  private int number = 0;

  public  synchronized void increment(){
      
    while(number!=0){
      //判断
      //等待
      this.wait();
    }

    //业务
    number++;

    //通知其他线程
    this.notifyAll();
  }
}
```

-JUC版

class Data{
    
  private int number = 0;
  private Lock lock = new ReentrantLock();
  private Condition condition=lock.newCondition();

  public void increment(){
    
    lock.lock();
    try{
    
      while(number!=0){
    //判断
        //等待
        condition.await();
      }

      //业务
      number++;

      //通知其他线程
      condition.signalAll();
      //conditionX.signal==>唤醒指定的监视器

    }catch(Exception e){
    
      e.printStackTrace();
    }finally{
    
      lock.unlock();
    }

  }
}

ReadWriteLock & 缓存

  public class ReadWriteLockDemo {
    
      public static void main(String[] args) {
    
          MyCacheLock cache = new MyCacheLock();

          for (int i = 1; i <= 5; i++) {
    
              int temp = i;
              new Thread(() -> {
    
                  cache.put(String.valueOf(temp), temp);
              }, String.valueOf(i)).start();
          }

          for (int i = 1; i <= 5; i++) {
    
              int temp = i;
              new Thread(() -> {
    
                  cache.get(String.valueOf(temp));
              }, String.valueOf(i)).start();
          }
      }
  }

  class MyCacheLock {
    
      private volatile Map<String, Object> map = new HashMap<>();

      private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

      public void put(String key, Object value) {
    
          readWriteLock.writeLock().lock();
          try {
    
              System.out.println(Thread.currentThread().getName() + "put" + key);
              map.put(key, value);
              System.out.println(Thread.currentThread().getName() + "put done");
          } catch (Exception e) {
    
              e.printStackTrace();
          } finally {
    
              readWriteLock.writeLock().unlock();
          }
      }

      public void get(String key) {
    
          readWriteLock.readLock().lock();
          try {
    
              System.out.println(Thread.currentThread().getName() + "get" + key);
              Object o = map.get(key);
              System.out.println(Thread.currentThread().getName() + "get done");
          } catch (Exception e) {
    
              e.printStackTrace();
          } finally {
    
              readWriteLock.readLock().unlock();
          }
      }

  }

  class MyCache {
    
      private volatile Map<String, Object> map = new HashMap<>();

      public void put(String key, Object value) {
    
          System.out.println(Thread.currentThread().getName() + "put" + key);
          map.put(key, value);
          System.out.println(Thread.currentThread().getName() + "put done");
      }

      public void get(String key) {
    
          System.out.println(Thread.currentThread().getName() + "get" + key);
          Object o = map.get(key);
          System.out.println(Thread.currentThread().getName() + "get done");
      }

  }

八锁现象-synchronized锁的对象

锁的对象: synchronized的调用者

八锁现象

集合类不安全

ArrayList不安全

  public class ListTest {
    
      public static void main(String[] args) {
    
          List<String> list = new ArrayList<>();
          for (int i = 1; i < 10; i++) {
    
              new Thread(() -> {
    
                  list.add(UUID.randomUUID().toString());
                  System.out.println(list);
              },String.valueOf(i)).start();
          }
      }
  }

java.util.ConcurrentModificationException 并发修改异常

解决方案:
1. Vector默认是安全的 List<String> list = new Vector<>();
2. 用工具类Collections使Arraylist安全 List<String> list = Collections.synchronizedList(new ArrayList<>());
3. JUC List<String> list = new CopyOnWriteArrayList<>();
CopyOnWrite -> COW写入时复制

CopyOnWriteList对比Vector -> synchronized效率低

Vector

  public synchronized boolean add(E e) {
        
      modCount++;
      ensureCapacityHelper(elementCount + 1);
      elementData[elementCount++] = e;
      return true;
  }

CopyOnWriteList

  public boolean add(E e) {
        
      final ReentrantLock lock = this.lock;
      lock.lock();
      try {
        
          Object[] elements = getArray();
          int len = elements.length;
          Object[] newElements = Arrays.copyOf(elements, len + 1);
          newElements[len] = e;
          setArray(newElements);
          return true;
      } finally {
        
          lock.unlock();
      }
  }

HashMap不安全

public class HasMapTest {
    
    public static void main(String[] args) {
    
        Map<String, String> map = new HashMap<>();
        for (int i = 1; i < 10; i++) {
    
            new Thread(() -> {
    
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString());
                System.out.println(map);
            }, String.valueOf(i)).start();
        }
    }
}

解决方法
1. Collections Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
2. JUC Map<String, String> map = new ConcurrentHashMap<>();

Callable

Runable	Callable
无返回值	返回值
无异常抛出	抛出异常
run()	call()

new Thread()中只接收Runnable,FutrueTask是Runable的子类,用于适配Callable

传统Runnable

  public class RunnableTest {
      
      public static void main(String[] args) {
      
          new Thread(new MyThreadRun(), "Runnable").start();
      }
  }

  class MyThreadRun implements Runnable {
      
      @Override
      public void run() {
      
          System.out.println("run()");
      }
  }

Callable

  public class CallableTest {
      
      public static void main(String[] args) throws ExecutionException, InterruptedException {
      

          MyThreadCall callableThread = new MyThreadCall();
          FutureTask futureTask = new FutureTask(callableThread);

          new Thread(futureTask, "Callable").start();

          System.out.println((String) futureTask.get());
      }

  }

  class MyThreadCall implements Callable<String> {
      
      @Override
      public String call() throws Exception {
      
          System.out.println("call()");
          return "call done";
      }
  }

get()会产生阻塞 -> 1. 需要等待 2. 使用异步处理

结果会被缓存,提高效率->两个线程输出一个结果

常用的辅助类

CountDownLatch

public class CountDownLatchDemo {
    
    public static void main(String[] args) throws InterruptedException {
    
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
    
            new Thread(() -> {
    
                System.out.println(Thread.currentThread().getName());
                countDownLatch.countDown();// 计数器减一
            }, String.valueOf(i)).start();
        }

        countDownLatch.await();// 等待计数器归零后向下执行

        System.out.println("done");

    }
}

CyclicBarrier

  public class CyclicBarrierDemo {
    
      public static void main(String[] args) {
    
          CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
    
              System.out.println("done");
          });

          for (int i = 1; i <= 7; i++) {
    
              int temp = i;
              new Thread(()->{
    
                  System.out.println(Thread.currentThread().getName());
                  try {
    
                      cyclicBarrier.await();
                  } catch (InterruptedException e) {
    
                      e.printStackTrace();
                  } catch (BrokenBarrierException e) {
    
                      e.printStackTrace();
                  }
              }).start();

          }
      }
  }

Semaphore

信号量

  public class SemaphoreDemo {
    
      public static void main(String[] args) {
    
          Semaphore semaphore = new Semaphore(6);
          for (int i = 1; i <= 12; i++) {
    
              new Thread(() -> {
    
                  try {
    
                      semaphore.acquire();
                      System.out.println(Thread.currentThread().getName() + "run");
                      TimeUnit.SECONDS.sleep(2);
                      System.out.println(Thread.currentThread().getName() + "done");
                  } catch (InterruptedException e) {
    
                      e.printStackTrace();
                  } finally {
    
                      semaphore.release();
                  }
              }, String.valueOf(i)).start();
          }
      }
  }

共享资源互斥时

并发限流,控制最大的线程数 -> 安全,高可用

BlockingQueue 阻塞队列

线程池,多线程使用
BlockingDueue双端队列

方式	抛异常	有返回值,不抛异常	阻塞等待	超时等待
添加	add()	offer()	put()	offer(,)
移除	remove()	poll()	take()	poll(,)
判断队列首	element()	peek()	-	-

在队列元素为空的情况下，element() 方法会抛出NoSuchElementException异常，peek() 方法只会返回 null

    public static void test1() {
    
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.add("A"));
        System.out.println(blockingQueue.add("B"));
        System.out.println(blockingQueue.add("C"));
        /// java.lang.IllegalStateException: Queue full
        //System.out.println(blockingQueue.add("D"));

        System.out.println("---");

        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        /// java.util.NoSuchElementException
        //System.out.println(blockingQueue.remove());
    }

    public static void test2() {
    
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("A"));
        System.out.println(blockingQueue.offer("B"));
        System.out.println(blockingQueue.offer("C"));
        //队列满则返回false
        System.out.println(blockingQueue.offer("D"));

        System.out.println("---");

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        //无对象则返回null
        System.out.println(blockingQueue.poll());

    }

    public static void test3() throws InterruptedException {
    
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        blockingQueue.put("A");
        blockingQueue.put("B");
        blockingQueue.put("C");
        ///队列满则阻塞等待
        //blockingQueue.put("D");

        System.out.println("---");

        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        ///队列空则阻塞等待
        //System.out.println(blockingQueue.take());
    }

    public static void test4() throws InterruptedException {
    
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("A"));
        System.out.println(blockingQueue.offer("B"));
        System.out.println(blockingQueue.offer("C"));
        //队列满则阻塞等待2s
        System.out.println(blockingQueue.offer("D", 2, TimeUnit.SECONDS));

        System.out.println("---");

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        //队列空则阻塞等待2s
        System.out.println(blockingQueue.poll(2, TimeUnit.SECONDS));
    }

    public static void test5() {
    
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(3);

        //为空则返回null
        System.out.println(blockingQueue.peek());

        //java.util.NoSuchElementException
        System.out.println(blockingQueue.element());
    }

SychronousQueue

同步队列
每次put之后必须先take,才可继续put

public class SynchronousQueueTest {
    
    public static void main(String[] args) {
    
        SynchronousQueue<String> synchronousQueue = new SynchronousQueue<>();

        new Thread(() -> {
    
            try {
    
                System.out.println(Thread.currentThread().getName() + "put 1");
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "put 2");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "put 3");
                synchronousQueue.put("3");
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            } finally {
    
                System.out.println("T1 over");
            }

        }, "T1").start();

        new Thread(() -> {
    
            try {
    
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "take " + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "take " + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + "take " + synchronousQueue.take());
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            } finally {
    
                System.out.println("T2 over");
            }

        }, "T2").start();
    }
}

线程池

3大方法
- Executors.newSingleThreadExecutor();
- Executors.newFixedThreadPool(5);
- Executors.newCachedThreadPool();
7大参数
- int corePoolSize 核心线程池大小
- int maximumPoolSize 最大核心线程池大小
- long keepAliveTime 等待超时时间
- TimeUnit unit 超时单位
- BlockingQueue<Runnable> workQueue 阻塞队列
- ThreadFactory threadFactory 线程工厂
- RejectedExecutionHandler handler 拒绝策略
4种拒绝策略
- AbortPolicy() :默认,不处理新的任务且抛出异常
- CallerRunsPolicy() :原路返回,返回给请求的线程处理
- DiscardPolicy() :队列满了后丢弃任务,不抛异常
- DiscardOldestPolicy() :队列满了后,丢弃最老的任务,不抛异常

最大线程池大小

CPU密集型 -> CPU核数 Runtime.getRuntime().availableProcessors();

IO密集型 -> 判断十分耗IO的线程数

public class PoolDemo1 {
    
    public static void main(String[] args) {
    
        ///单线程,最多1个线程
        //ExecutorService pool = Executors.newSingleThreadExecutor();

        ///固定线程,最多n个线程
        //ExecutorService pool = Executors.newFixedThreadPool(5);

        ///可变线程,任意个线程
        //ExecutorService pool = Executors.newCachedThreadPool();

        //本质都是调用ThreadPoolExecutor
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy()
        );
        /**
         * 1. 核心线程池大小    -> 默认为0
         * 2. 最大核心线程池大小 -> 默认为Integer.MAX_VALUE => 会造成OOM
         * 3. 等待超时时间
         * 4. 超时单位
         * 5. 阻塞队列
         * 6. 线程工厂(一般不动)
         * 7. 拒绝策略
         *      AbortPolicy() :默认,不处理新的任务且抛出异常
         *      CallerRunsPolicy() :原路返回,返回给请求的线程处理
         *      DiscardPolicy() :队列满了后丢弃任务,不抛异常
         *      DiscardOldestPolicy() :队列满了后,丢弃最老的任务,不抛异常
         */

        try {
    
            for (int i = 0; i < 20; i++) {
    
                pool.execute(() -> {
    
                    System.out.println(Thread.currentThread().getName()+"done");
                });
            }
        } catch (Exception e) {
    
            e.printStackTrace();
        } finally {
    
            pool.shutdown();
        }
    }
}

四大函数接口

Function 函数型接口

    public class FunctionTest1 {
      
        public static void main(String[] args) {
      
    //        Function<String, String> function = new Function<String, String>() {
      
    //            @Override
    //            public String apply(String s) {
      
    //                return s;
    //            }
    //        };

            Function<String, String> function = (str) -> {
      
                return str;
            };

            System.out.println(function.apply("hahaha"));
        }
    }

Predicate 断定型接口

    public class PredicateTest {
      
        public static void main(String[] args) {
      
    //        Predicate<String> predicate = new Predicate<String>() {
      
    //            @Override
    //            public boolean test(String s) {
      
    //                return s.isEmpty();
    //            }
    //        };

            Predicate<String> predicate = (s) -> {
      
                return s.isEmpty();
            };

            System.out.println(predicate.test("hahaha"));
        }
    }

Consumer 消费型接口

    public class ConsumerTest {
      
        public static void main(String[] args) {
      
    //        Consumer<String> consumer = new Consumer<String>(){
      
    //            @Override
    //            public void accept(String s) {
      
    //                System.out.println(s);
    //            }
    //        };

            Consumer<String> consumer = (s) -> {
      
                System.out.println(s);
            };

            consumer.accept("hahaha");

        }
    }

Supplier 供给型接口

    public class SupplierTest {
      
        public static void main(String[] args) {
      
    //        Supplier<String> supplier = new Supplier<String>() {
      
    //            @Override
    //            public String get() {
      
    //                return "hahaha";
    //            }
    //        };
            Supplier<String> supplier = () -> {
      
                return "hahaha";
            };

            System.out.println(supplier.get());
        }
    }

Stream流式计算

filter 过滤器

Predicate断定接口
map 映射

Function函数型接口
sorted 排序

Comparator -> Function函数型接口
limit 分页

Long
forEach 遍历

Consumer消费型接口

    public class StreamTest {
    
        public static void main(String[] args) {
    
            User u1 = new User(1, "a", 20);
            User u2 = new User(2, "b", 21);
            User u3 = new User(3, "c", 22);
            User u4 = new User(4, "d", 23);
            User u5 = new User(5, "e", 24);
            User u6 = new User(6, "f", 25);

            List<User> users = Arrays.asList(u1, u2, u3, u4, u5, u6);

            /**
            * 1. ID为偶数
            * 2. 年龄大于20
            * 3. 用户名转大写
            * 4. 倒序
            * 5. 只输出2个
            */
            users.stream()
                    .filter((u) -> {
    
                        return u.getId() % 2 == 0;
                    })
                    .filter((u) -> {
    
                        return u.getAge() > 20;
                    })
                    .map((u) -> {
    
                        return u.getName().toUpperCase();
                    })
                    .sorted((user1, user2) -> {
    
                        return user2.compareTo(user1);
                    })
                    .limit(2)
                    .forEach(System.out::println);

            /**
            * filter 过滤器,Predicate断定接口
            * map 映射,Function函数型接口
            * sorted 排序,Comparator -> Function函数型接口
            * limit 分页,Long
            * forEach 遍历,Consumer消费型接口
            */
        }
    }

ForkJoin

并行执行任务
特点: 任务窃取

以双端队列作线程,在任务完成后会从其他队列的尾端抢夺其他的线程的任务

forkjoinPool
计算任务 forkjoinPool.execute(ForkJoinTask take)
计算类要继承ForkJoinTask

ForkJoinTask
- CountedCompleter
- RecursiveAction
- RecursiveTask


public class ForkJoinTest {
    
    public static void main(String[] args) {
    
        test1();

        System.out.println("=====");

        try {
    
            test2();
        } catch (ExecutionException | InterruptedException e) {
    
            e.printStackTrace();
        }

        System.out.println("=====");

        test3();
        /*
        sum=500000000500000000,用时:330
                =====
        sum=500000000500000000,用时:294
                =====
        sum=500000000500000000,用时:219
        */

    }

    //普通方法
    public static void test1() {
    
        long sum = 0L;
        long start = System.currentTimeMillis();

        for (long i = 1L; i <= 10_0000_0000L; i++) {
    
            sum += i;
        }

        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + ",用时:" + (end - start));
    }

    //Forkjoin
    public static void test2() throws ExecutionException, InterruptedException {
    
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> forkJoinDemo = new ForkJoinDemo(1L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(forkJoinDemo);

        long sum = submit.get();

        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + ",用时:" + (end - start));
    }

    //stream
    public static void test3() {
    
        long start = System.currentTimeMillis();
        long sum = LongStream
                .rangeClosed(0L, 10_0000_0000L)
                .parallel()
                .reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + ",用时:" + (end - start));
    }
}

class ForkJoinDemo extends RecursiveTask<Long> {
    
    private final long start;
    private final long end;

    public ForkJoinDemo(long start, long end) {
    
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
    

        long temp = 10000L;
        if ((end - start) < temp) {
    
            long sum = 0L;
            for (long i = start; i <= end; i++) {
    
                sum += i;
            }
            return sum;
        } else {
    
            long middle = (start + end) / 2;
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            ForkJoinDemo task2 = new ForkJoinDemo(middle + 1, end);

            task1.fork();
            task2.fork();

            return task1.join() + task2.join();
        }
    }
}

Future

Interface Future<V>
- CompletableFuture<T>


public class FutureTest {
    

    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
        //无返回值
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
    
            try {
    
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "runAsync");

        });

        System.out.println("-----");

        completableFuture.get();

        System.out.println("============");
        //有返回值
        CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
    
            System.out.println(Thread.currentThread().getName() + "supplyAsync");
            int i = 10 / 0;
            return 1024;
        });

        System.out.println(completableFuture1.whenComplete((t, u) -> {
    
            System.out.println("t=" + t);//正常结果
            System.out.println("u=" + u);//错误信息
        }).exceptionally((e) -> {
    
            System.out.println(e.getMessage());
            return -1;//错误时的结果
        }).get());

    }
}

JMM

java内存模型(概念,模型)

JMM特征
- 原子性
- 可见性
- 有序性
JMM操作
- lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
- unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
- read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
- load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
- use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
- assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
- store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
- write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中
JMM的约定
1. 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
2. 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
3. 不允许一个线程将没有assign的数据从工作内存同步回主内存
4. 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
5. 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
6. 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
7. 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
8. 对一个变量进行unlock操作之前，必须把此变量同步回主内存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9TSEyfPP-1606395141515)(images/JMM模型.png)]

主内存对应的是Java堆中的对象实例部分，工作内存对应的是栈中的部分区域，从更底层的来说，主内存对应的是硬件的物理内存，工作内存对应的是寄存器和高速缓存。

Happen-Before（先行发生规则）

Volatile

Volatile是Java虚拟机提供的轻量级同步机制

保证可见性
不保证原子性
禁止指令重排
- 在volatile标记的指令前后添加内存屏障(同时实现可见性)

指令重排:编译器优化,指令并行,内存系统


public class VolatileTest {
    
    //private static int num = 0;
    //private static volatile int num = 0;//加了volatile后,线程可以感知num的变化,但无法保证原子性
    private static volatile AtomicInteger num = new AtomicInteger();
    /*
    1. lock
    2. sychronized
    3. 使用Atomic类
     */

    public static void main(String[] args) {
    
        testVisibility();

        System.out.println("======");

        testAtomic();
    }

    static void testVisibility(){
    
        Thread thread = new Thread(new Runnable() {
    
            @Override
            public void run() {
    
//                while (num == 0) {
    
//
//                }
                while (num.get()==0){
    //AtomicInteger不能直接等于

                }
                System.out.println("线程感知num值改变");
            }
        });

        thread.start();

        try {
    
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }

        //num = 1;
        num.set(1);
        System.out.println(num);
    }



    public static void testAtomic(){
    
        for (int i = 0; i < 20; i++) {
    
            Thread thread = new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    for (int j = 0; j < 1000; j++) {
    
                        //num++;
                        num.getAndIncrement();//AtomicInteger + 1,方法CAS
                    }
                }
            });

            thread.start();
        }

        while (Thread.activeCount()>2){
    
            Thread.yield();
        }

        System.out.println(num);

    }
}

单例模式

饿汉式单例


//饿汉式单例:在加载时就创建对象,可能会浪费内存
public class HungryManTest {
      
    private HungryManTest() {
      
        System.out.println(Thread.currentThread().getName());
    }

    private final static HungryManTest HUNGRY_MAN_TEST = new HungryManTest();

    public static HungryManTest getInstance(){
      
        return HUNGRY_MAN_TEST;
    }

    public static void main(String[] args) {
      
        for (int i = 0; i < 10; i++) {
      
            Thread thread = new Thread(new Runnable() {
      
                @Override
                public void run() {
      
                    HungryManTest.getInstance();
                }
            });

            thread.start();
        }
    }
}

懒汉式单例

package com.checker.singleton;

public class LazyManTest {
      
    private LazyManTest() {
      
        System.out.println(Thread.currentThread().getName());
    }

    private static volatile LazyManTest lazyManTest;

    public static LazyManTest getInstance(){
      
//        if (lazyManTest == null){
      
//            lazyManTest = new LazyManTest();
//        }
        ///使用双重检测模式:DCL懒汉式
        if (lazyManTest == null){
      
            synchronized (LazyManTest.class){
      
                if (lazyManTest == null){
      
                    lazyManTest = new LazyManTest();
                }
            }
        }

        return lazyManTest;
    }

    public static void main(String[] args) {
      
        //多线程下单例模式失效
        for (int i = 0; i < 10; i++) {
      
            Thread thread = new Thread(new Runnable() {
      
                @Override
                public void run() {
      
                    LazyManTest.getInstance();
                }
            });

            thread.start();
        }
    }
}

静态内部类

public class StaticInnerTest {
      
    private StaticInnerTest(){
      

    }

    public static class InnerClass{
      
        private static final StaticInnerTest staticInnerTest = new StaticInnerTest();
    }

    //利用静态内部类返回单例对象
    public static StaticInnerTest getInstance(){
      
        return InnerClass.staticInnerTest;
    }
}

反射破坏单例与枚举

public class SingletonAndReflection {
      
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
      
        //普通方法获取单例
        LazyManTest instance1 = LazyManTest.getInstance();

        //用反射破坏单例
        Constructor<LazyManTest> declaredConstructor = LazyManTest.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        //通过反射获取的构造器创建单例
        LazyManTest instance2 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
        /*
        解决方法: 在构造方法中,先将class锁住,判断类模板是否存在,存在则抛出异常

        破解方法: 所有对象都为反射创建,不加载类模板

        解决方法2: 添加一个flag判断,在对象创建的时候判断flag的值

        破解方法2: 用反射再获取修改这个flag

        最终方法: 用枚举类创建单例
        */

        Constructor<EnumSingle> enumSingleConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        enumSingleConstructor.setAccessible(true);
        //报错: 无法通过反射创建枚举对象
        EnumSingle instance3 = enumSingleConstructor.newInstance();

        System.out.println(instance3);
    }
}

enum EnumSingle{
      
    INSTANCE;

    public EnumSingle getInstance(){
      
        return INSTANCE;
    }
}

CAS

compare and swap

比较并交换

public class CASTest {
    
    //CAS compare and swap

    public static void main(String[] args) {
    
        AtomicInteger atomicInteger = new AtomicInteger(10);

        System.out.println(atomicInteger);

        //如果当前对象值为 expect:10 则将对象设置为 update:11
        atomicInteger.compareAndSet(10,12);
        System.out.println(atomicInteger);

        //CAS自增1,底层为自旋锁
        atomicInteger.getAndIncrement();
        System.out.println(atomicInteger);
    }
}

ABA问题

原子引用

public class ABATest {
    

    public static void main(String[] args) {
    
        AtomicInteger atomicInteger = new AtomicInteger(10);
        AtomicStampedReference<Integer> atomicReference = new AtomicStampedReference<>(10, 0);

        new Thread(new Runnable() {
    
            @Override
            public void run() {
    
                //获取原本的版本号
                int stamp = atomicReference.getStamp();
                System.out.println("stamp:" + stamp);

                try {
    
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                }

                System.out.println("带时间戳");
                System.out.println(atomicReference.compareAndSet(10, 100, stamp, stamp + 1));
                System.out.println(atomicReference.getReference());

                System.out.println("不带时间戳");
                System.out.println(atomicInteger.compareAndSet(10, 100));
                System.out.println(atomicInteger);
            }
        }, "T1").start();

        new Thread(new Runnable() {
    
            @Override
            public void run() {
    
                int stamp = atomicReference.getStamp();
                atomicReference.compareAndSet(10, 30, stamp, stamp + 1);

                stamp = atomicReference.getStamp();
                atomicReference.compareAndSet(30, 10, stamp, stamp + 1);

                atomicInteger.compareAndSet(10, 30);

                atomicInteger.compareAndSet(30, 10);
            }
        }, "T2").start();
    }

}

int在大小超过-127~127时,会new新的对象,应该用Interger类进行操作
//获取原本的版本号
int stamp = atomicReference.getStamp();
System.out.println(“stamp:” + stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("带时间戳");
            System.out.println(atomicReference.compareAndSet(10, 100, stamp, stamp + 1));
            System.out.println(atomicReference.getReference());

            System.out.println("不带时间戳");
            System.out.println(atomicInteger.compareAndSet(10, 100));
            System.out.println(atomicInteger);
        }
    }, "T1").start();

    new Thread(new Runnable() {
        @Override
        public void run() {
            int stamp = atomicReference.getStamp();
            atomicReference.compareAndSet(10, 30, stamp, stamp + 1);

            stamp = atomicReference.getStamp();
            atomicReference.compareAndSet(30, 10, stamp, stamp + 1);

            atomicInteger.compareAndSet(10, 30);

            atomicInteger.compareAndSet(30, 10);
        }
    }, "T2").start();
}

}


> int在大小超过-127~127时,会new新的对象,应该用Interger类进行操作

本文链接：https://blog.csdn.net/weixin_44535556/article/details/110204565

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

NSStringDrawingOptions_yinachong的博客-程序员宅基地

NSStringDrawingTruncatesLastVisibleLine：如果文本内容超出指定的矩形限制，文本将被截去并在最后一个字符后加上省略号。如果没有指定NSStringDrawingUsesLineFragmentOrigin选项，则该选项被忽略。NSStringDrawingUsesLineFragmentOrigin：绘制文本时使用 line fragement or

条件注解@ConditionalOnBean失效原因_zhm_sky的博客-程序员宅基地_conditionalonbean不生效

测试环境（配置类）@Import({User.class,Pet.class})@Configuration(proxyBeanMethods = true)public class MyConfig { @Bean @ConditionalOnBean(name = "cat") public User user(){ return new User("航书", 12); } @Bean("cat") public

一重指针、二重指针做函数参数的深刻分析（虽然很基础，但要深刻理解）_ShenHang_的博客-程序员宅基地

一重指针做函数参数#include<iostream>using namespace std;void change(int *p){ *p = 20; p++; cout << p << endl;}int main() { int a = 10; change(&a); cout << &a <&lt...

java设置图片点击渐变透明,图片实现渐变/透明效果_weixin_39569753的博客-程序员宅基地

众所周知，图片等一些盒子都可以利用opacity属性来设置不透明度，但是前两天我朋友忽然给我一个截图，截图效果如下图中红框圈住的位置图片或者说摄像头采集的画面出现了渐变到透明，可以清楚的看到可以看到后面小哥的胳膊，然后问我如何实现这种效果，这下把我难住了(呵天天给我出难题)，我开始在个大论坛开始寻找解决方案；忽然在前天，日常逛论坛时看到一个文字投影的效果，而后忽然灵机一动就想，能不能变相的实现前...

java笔记_笑容温暖城寨的博客-程序员宅基地

安卓课的Java扩展笔记包类命名规范总结输出换行与不换行mian方法中的args参数Math类快捷输出语句static关键字定义无参方法定义带返回值方法包package com.eoe.basic.day01;//包名在java当中用.表示windos中的/，一般格式：com.公司名.项目名.业务模块名称例如：com.sina.crm.user类命名规范总结1、java中可以有多个类2、java中可以有多个类，但是最多只有一个类的类名和文件名相同3、如果一个类被public修饰，那该类

一、网络游戏架构的前世今生（2）_王元恺David的博客-程序员宅基地

网络游戏架构演进史，优化游戏网络，自定义网络协议

JUC（自用）【未完成】_鲤鱼非鱼的博客-程序员宅基地

JUC

目录

文章目录

多线程

线程和进程

并发和并行

线程的状态

wait/sleep

java.util.concurrent.locks

LOCK & synchronized

Condition & 生产者/消费者

ReadWriteLock & 缓存

八锁现象-synchronized锁的对象

集合类不安全

ArrayList不安全

HashMap不安全

Callable

常用的辅助类

CountDownLatch

CyclicBarrier

Semaphore

BlockingQueue 阻塞队列

SychronousQueue

线程池

四大函数接口

Stream流式计算

ForkJoin

Future

JMM

Happen-Before（先行发生规则）

Volatile

单例模式

CAS

compare and swap

ABA问题

智能推荐

随便推点

推荐文章

热门文章

相关标签