JUC（自用）【未完成】_如何下载未编译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

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

智能推荐

The BOOkList of Software Engineering_object oriented software development method and ap-程序员宅基地

文章浏览阅读2.2k次。软件工程分类比较麻烦，很多东西界限比较模糊，我大致按以下进行分类,欢迎提意见。仅仅列举可以获得的书籍(电子版或者可以在国内买到的纸版) 1.软件方法学 (传统结构化方法 OO component agent 形式化方法 MDA aop fop 净室开发基于软件体系结构的软件开发方法) 2.软件过程( xp rup 传统软件开发过程 ) 3.项目管理 (项目计划风险管理进度管理配置管理团队_object oriented software development method and application

操作系统实验一：CPU调度（优先级调度、时间片轮转调度）_操作系统实验编写程序模拟处理机调度,参照图3。 (1) 时间片轮转 (2) 动态优先权调-程序员宅基地

文章浏览阅读2.2k次，点赞3次，收藏54次。操作系统实验一，采用优先级调度算法和时间片轮转调度算法实现进程的动态添加、挂起、解挂、调度信息公示_操作系统实验编写程序模拟处理机调度,参照图3。 (1) 时间片轮转 (2) 动态优先权调

C# WinForm 选择打开文件和保存文件_winform 打开文件-程序员宅基地

文章浏览阅读3.7k次。属性我们可以文件的设置默认的保存名称，这里我们只需要填写名称即可，不需要文件的保存路径，还有一些其他配置写在代码注释中了。属性获取文件保存位置的完整路径，之后通过 IO 将数据写入即可。如果你想在用户在选择框取消选择时做一些事情，你可以通过。如果用户想要打开一个保存文件的窗口，就需要选用。如果用户需要选择多个文件，可以通过设置。当用户选择完毕文件后，我们可以通过。属性拿到的是第一个文件的路径，而。可以设置可以保存的格式，通过。和打开文件时一样，我们可以通过。属性可以获取到选择的文件。属性来开启多选，此时。_winform 打开文件

CoreData数据库加密-程序员宅基地

文章浏览阅读280次。iOS App 如果使用sqllite数据库存储,就存在数据库安全问题,可以采用一定方式对数据库文件加密或内容进行加密.以下是一些加密的思路和加密方式1.对数据库文件进行加密2.对存储的内容进行加密,比如对某些重要字段进行加密,加密方式可以采用AES ,Base64,MD5等,其中MD5加密不可逆.以下内容采用SQLCipher对CoreData数据库内容进行加密. SQL..._coredata 加密

Python官方网站地址及源代码_python源代码网站-程序员宅基地

文章浏览阅读930次。这些示例代码只是Python语言的冰山一角，Python官方网站提供了更多的教程、文档和资源，供开发者学习和参考。通过访问Python官方网站，您可以深入了解Python语言的各个方面，并掌握其强大的功能和用途。以上代码定义了两个变量x和y，并对它们进行加法运算，将结果保存在变量result中，并通过print函数输出结果。以上代码定义了一个函数add_numbers，用于计算两个数的和，并通过调用函数并输出结果来演示函数的使用。以上代码根据age的值判断一个人是否成年，并输出相应的结果。_python源代码网站

ibatis 使用文档（上篇）-程序员宅基地

文章浏览阅读108次。（代码下载地址：http://download.csdn.net/detail/partner4java/4760043）iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。创建于2002年，后很快加入了Apache，但是2010年又易主到google code，并改名为MyBatis。本篇文章主要是基于iBATIS来进行展示，后面会再发..._apache ibatis文档

随便推点

Springboot集成FastDFS查看文件是否存在_fastdfs判断文件是否存在-程序员宅基地

文章浏览阅读1.1k次。最近做的项目出现了一个bug(没考虑周全)，Fastdfs把图片删掉之后，数据库中的数据还存在，导致扫描器执行删除程序时报错：错误结点2找到不该文件。原因是Fastdfs删除图片用的是自带的路径判断方法，因为数据库中存在该条记录，所以url不为空。即：!xxx.getFDFSFileUrl().isEmpty()）该语句不管删图片与否，一直为ture，于是调研Fastdfs是否有自带的判断文件是否存在的方法。没有直接判断是否存在的方法，找到获取文件详情的方法，网上获取文件详情后判断是否的方法_fastdfs判断文件是否存在

【雕爷学编程】Arduino动手做（103）---四路无线遥控套件_遥控芯片2241坏编码-程序员宅基地

文章浏览阅读1.6k次，点赞2次，收藏21次。雕爷学编程,Arduino动手做,开源硬件,创客传感器,四路无线遥控套件_遥控芯片2241坏编码

下列不是python对文件的操作方法的是_Python文件操作方法详解-程序员宅基地

文章浏览阅读1.9k次。本节内容1、文件常用操作汇总2、打开文件3、操作文件4、关闭文件一、文件常用操作汇总二、打开文件1、普通打开模式r，英文：read，只读模式(默认)w，英文：write，只写模式（不可读，不存在则创建新文件，存在则删除内容）a，英文：append，追加模式(不可读，不存在则创建，存在则只追加内容2、同时读写模式r+,可读写文件(可读；可写；可追加，不存在文件则报错)w+,可写读文件（可读，可写，创..._不是python对文件读写操作方法的是a.'r'b,'w'c,'b+'d'c

前端Promise相关面试题以及知识点_前端面试题-使用 promise 是为了解决什么问题-程序员宅基地

文章浏览阅读2.3k次，点赞4次，收藏14次。什么是Promise？Promise 是异步编程的一种解决方案：从语法上讲，promise是一个对象，从它可以获取异步操作的消息；从本意上讲，它是承诺，承诺它过一段时间会给你一个结果。promise有三种状态：pending(等待态)，fulfiled(成功态)，rejected(失败态)；状态一旦改变，就不会再变。创造promise实例后，它会立即执行。我们用Promise来解决什么问题？promise是用来解决两个问题的：回调地狱，代码难以维护，常常第一个的函数的输出是第二个函数._前端面试题-使用 promise 是为了解决什么问题

request和response的区别!!!-程序员宅基地

文章浏览阅读3.7w次，点赞141次，收藏542次。文章目录一、request和response介绍二、request对象（一）获取请求参数（二）实现请求转发（三）作为域对象使用（四）案例:模拟查询所有门店功能三、response对象（一）向客户端发送数据（二）实现重定向一、request和response介绍request是代表HTTP请求信息的对象，response是代表HTTP响应信息的对象。当浏览器发请求访问服务器中的某一个Servlet时，服务器将会调用Servlet中的service方法来处理请求。在调用service方法之前会创_request和response

Android中获取当前位置的使用步骤_为获取旅行中寻找现在的位置及我的位置信息而使用-程序员宅基地

文章浏览阅读8k次，点赞3次，收藏4次。在Android中得到当前位置的步骤1.在AndroidManifest.xml中声明权限android.permission.ACCESS_FINE_LOCATION(或者android.permission.ACCESS_COARSE_LOCATION)2.声明并实例化一个L_为获取旅行中寻找现在的位置及我的位置信息而使用