From 98ab610d626f0f5a8bf954a2e4268dc7dff0e61a Mon Sep 17 00:00:00 2001 From: Shusheng Shi <2855845850@qq.com> Date: Sun, 1 Apr 2018 03:35:52 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BC=98=E5=8C=96=E5=86=85=E5=AE=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 26 ++ LICENSE | 201 +++++++++++++ README.md | 78 +++++ assets/LOGO.png | Bin 0 -> 100047 bytes "assets/QQ \347\276\244.JPG" | Bin 0 -> 320618 bytes ...\344\272\272\345\276\256\344\277\241.jpeg" | Bin 0 -> 187205 bytes .../\345\205\254\344\274\227\345\217\267.png" | Bin 0 -> 97548 bytes ...\345\276\256\344\277\241\347\276\244.jpeg" | Bin 0 -> 157149 bytes ...3\345\256\242\344\270\223\345\210\212.png" | Bin 0 -> 13222 bytes concurrency/src/main/java/AppendixA/Main.java | 9 + .../src/main/java/AppendixA/MyFrame.java | 63 ++++ .../src/main/java/Balking/Q5/TestThread.java | 15 + .../java/Balking/Sample/ChangerThread.java | 26 ++ .../src/main/java/Immutable/A6_2/Main.java | 31 ++ .../src/main/java/Immutable/Q2/Main.java | 8 + .../concurrency/ConcurrencyApplication.java | 32 ++ .../javaedge/concurrency/ConcurrencyTest.java | 50 ++++ .../com/javaedge/concurrency/HttpFilter.java | 35 +++ .../javaedge/concurrency/HttpInterceptor.java | 25 ++ .../javaedge/concurrency/TestController.java | 17 ++ .../concurrency/annoations/NotRecommend.java | 16 + .../concurrency/annoations/NotThreadSafe.java | 16 + .../concurrency/annoations/Recommend.java | 16 + .../concurrency/annoations/ThreadSafe.java | 16 + .../concurrency/cas/demo/ConcurrentStack.java | 53 ++++ .../javaedge/concurrency/cas/demo/Node.java | 20 ++ .../javaedge/concurrency/cas/demo/Stack.java | 56 ++++ .../javaedge/concurrency/cas/demo/Test.java | 41 +++ .../javaedge/concurrency/common/Timer.java | 24 ++ .../common/closure/ThreadClosure.java | 45 +++ .../communication/ThreadCommunication.java | 227 +++++++++++++++ .../concurrency/common/state/ThreadState.java | 75 +++++ .../common/stop/FlagStopThread.java | 30 ++ .../common/stop/PrimeGenerator.java | 70 +++++ .../concurrency/common/stop/StopThread.java | 28 ++ .../concurrency/common/stop/ThreadStop.java | 26 ++ .../common/volatiletest/VisibilityDemo.java | 55 ++++ .../common/volatiletest/VisibilityDemo1.java | 39 +++ .../common/volatiletest/VisibilityDemo2.java | 42 +++ .../example/LockSupportBlockerTest.java | 30 ++ .../concurrency/example/LockSupportTest.java | 56 ++++ .../concurrency/example/UnsafeTest.java | 59 ++++ .../example/aqs/CountDownLatchExample1.java | 42 +++ .../example/aqs/CountDownLatchExample2.java | 42 +++ .../example/aqs/CyclicBarrierExample1.java | 38 +++ .../example/aqs/CyclicBarrierExample2.java | 43 +++ .../example/aqs/CyclicBarrierExample3.java | 40 +++ .../concurrency/example/aqs/SampleLock.java | 25 ++ .../concurrency/example/aqs/SimpleLock.java | 75 +++++ .../aqs/semaphore/MicrowaveOvenPool.java | 87 ++++++ .../example/aqs/semaphore/ObjPool.java | 71 +++++ .../aqs/semaphore/SemaphoreExample1.java | 42 +++ .../aqs/semaphore/SemaphoreExample2.java | 39 +++ .../aqs/semaphore/SemaphoreExample3.java | 41 +++ .../aqs/semaphore/SemaphoreExample4.java | 41 +++ .../aqs/semaphore/SemaphoreExample5.java | 53 ++++ .../aqs/semaphore/SemaphoreExample6.java | 34 +++ .../example/atomic/AtomicExample1.java | 49 ++++ .../example/atomic/AtomicExample2.java | 49 ++++ .../example/atomic/AtomicExample3.java | 48 +++ .../example/atomic/AtomicExample4.java | 22 ++ .../example/atomic/AtomicExample5.java | 33 +++ .../example/atomic/AtomicExample6.java | 50 ++++ .../example/atomic/AtomicTest.java | 26 ++ .../example/atomic/LockCASDemo.java | 72 +++++ .../example/atomic/LongAccumulatorDemo.java | 34 +++ .../example/atomic/LongAdderDemo.java | 73 +++++ .../example/cache/CacheController.java | 32 ++ .../example/cache/GuavaCacheExample1.java | 57 ++++ .../example/cache/GuavaCacheExample2.java | 67 +++++ .../example/cache/RedisClient.java | 42 +++ .../example/cache/RedisConfig.java | 19 ++ .../commonunsafe/ArrayListExample.java | 50 ++++ .../commonunsafe/DateFormatExample1.java | 51 ++++ .../commonunsafe/DateFormatExample2.java | 50 ++++ .../commonunsafe/DateFormatExample3.java | 50 ++++ .../example/commonunsafe/HashMapExample.java | 50 ++++ .../example/commonunsafe/HashSetExample.java | 50 ++++ .../example/commonunsafe/StringExample1.java | 47 +++ .../example/commonunsafe/StringExample2.java | 50 ++++ .../concurrent/ConcurrentHashMapExample.java | 50 ++++ .../ConcurrentSkipListMapExample.java | 50 ++++ .../ConcurrentSkipListSetExample.java | 50 ++++ .../CopyOnWriteArrayListExample.java | 50 ++++ .../CopyOnWriteArraySetExample.java | 50 ++++ .../example/condition/BlockedQueue.java | 58 ++++ .../example/condition/DubboCondition.java | 85 ++++++ .../example/count/CountExample1.java | 47 +++ .../example/count/CountExample2.java | 49 ++++ .../example/count/CountExample3.java | 47 +++ .../example/count/CountExample4.java | 50 ++++ .../example/deadLock/DeadLock.java | 68 +++++ .../example/forkjoin/ForkJoinTaskExample.java | 69 +++++ .../forkjoin/ForkJoinTaskExample2.java | 53 ++++ .../forkjoin/ForkJoinTaskExample3.java | 193 ++++++++++++ .../example/furure/guava/FutureExample.java | 54 ++++ .../furure/jdk/CompletableFutureDemo.java | 56 ++++ .../furure/jdk/CompletableFutureDemo2.java | 66 +++++ .../furure/jdk/CompletionServiceDemo.java | 144 +++++++++ .../example/furure/jdk/FutureExample.java | 34 +++ .../example/furure/jdk/FutureTaskExample.java | 32 ++ .../example/immutable/ImmutableExample1.java | 34 +++ .../example/immutable/ImmutableExample2.java | 29 ++ .../example/immutable/ImmutableExample3.java | 24 ++ .../concurrency/example/lock/Account.java | 71 +++++ .../concurrency/example/lock/CacheDemo1.java | 46 +++ .../concurrency/example/lock/CacheDemo2.java | 72 +++++ .../concurrency/example/lock/CacheDemo3.java | 59 ++++ .../concurrency/example/lock/LockDemo.java | 32 ++ .../example/lock/LockExample1.java | 51 ++++ .../example/lock/LockExample2.java | 56 ++++ .../example/lock/LockExample3.java | 52 ++++ .../example/lock/LockExample4.java | 59 ++++ .../example/lock/LockExample5.java | 58 ++++ .../example/lock/LockExample6.java | 43 +++ .../concurrency/example/lock/LockTest.java | 25 ++ .../concurrency/example/lock/LockTest2.java | 38 +++ .../concurrency/example/lock/Point.java | 42 +++ .../concurrency/example/lock/TicketLock.java | 23 ++ .../concurrency/example/mq/Message.java | 19 ++ .../concurrency/example/mq/MqController.java | 33 +++ .../example/mq/kafka/KafkaReceiver.java | 20 ++ .../example/mq/kafka/KafkaSender.java | 32 ++ .../example/mq/kafka/TopicConstants.java | 12 + .../example/mq/rabbitmq/QueueConstants.java | 12 + .../example/mq/rabbitmq/RabbitMqClient.java | 26 ++ .../example/mq/rabbitmq/RabbitMqConfig.java | 21 ++ .../example/mq/rabbitmq/RabbitMqServer.java | 19 ++ .../concurrency/example/publish/Escape.java | 28 ++ .../example/publish/UnsafePublish.java | 25 ++ .../example/singleton/SingletonExample1.java | 27 ++ .../example/singleton/SingletonExample2.java | 24 ++ .../example/singleton/SingletonExample3.java | 29 ++ .../example/singleton/SingletonExample4.java | 41 +++ .../example/singleton/SingletonExample5.java | 35 +++ .../example/singleton/SingletonExample6.java | 33 +++ .../example/singleton/SingletonExample7.java | 36 +++ .../example/streams/ParallelPrime.java | 40 +++ .../concurrency/example/streams/Summing.java | 44 +++ .../example/sync/ObjectSyncDemo1.java | 35 +++ .../example/sync/ObjectSyncDemo2.java | 18 ++ .../example/sync/ObjectSyncDemo3.java | 22 ++ .../example/sync/ObjectSyncDemo4.java | 33 +++ .../example/sync/SynchronizedExample1.java | 47 +++ .../example/sync/SynchronizedExample2.java | 40 +++ .../syncContainer/CollectionsExample1.java | 51 ++++ .../syncContainer/CollectionsExample2.java | 51 ++++ .../syncContainer/CollectionsExample3.java | 51 ++++ .../syncContainer/HashTableExample.java | 50 ++++ .../example/syncContainer/VectorExample1.java | 50 ++++ .../example/syncContainer/VectorExample2.java | 39 +++ .../example/syncContainer/VectorExample3.java | 45 +++ .../example/threadLocal/RequestHolder.java | 23 ++ .../threadLocal/ThreadLocalController.java | 21 ++ .../example/threadpermessage/EchoServer.java | 52 ++++ .../example/threadpool/MyThreadPool.java | 70 +++++ .../example/threadpool/ThreadPool2.java | 50 ++++ .../threadpool/ThreadPoolExample1.java | 26 ++ .../threadpool/ThreadPoolExample2.java | 26 ++ .../threadpool/ThreadPoolExample3.java | 26 ++ .../threadpool/ThreadPoolExample4.java | 42 +++ .../threadpool/ThreadPoolExample5.java | 275 ++++++++++++++++++ .../main/java/workerthread/v1/Channel.java | 87 ++++++ .../java/workerthread/v1/ClientThread.java | 33 +++ .../src/main/java/workerthread/v1/Main.java | 22 ++ .../main/java/workerthread/v1/Request.java | 36 +++ .../java/workerthread/v1/WorkerThread.java | 26 ++ .../main/java/workerthread/v2/Channel.java | 19 ++ concurrency/src/main/main.iml | 27 ++ .../src/main/resources/application.properties | 4 + .../ConcurrencyApplicationTests.java | 16 + concurrency/src/test/test.iml | 11 + license.txt | 22 ++ mvnw | 225 ++++++++++++++ mvnw.cmd | 143 +++++++++ pom.xml | 118 ++++++++ 176 files changed, 8097 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100755 README.md create mode 100644 assets/LOGO.png create mode 100644 "assets/QQ \347\276\244.JPG" create mode 100644 "assets/\344\270\252\344\272\272\345\276\256\344\277\241.jpeg" create mode 100644 "assets/\345\205\254\344\274\227\345\217\267.png" create mode 100644 "assets/\345\276\256\344\277\241\347\276\244.jpeg" create mode 100644 "assets/\347\211\233\345\256\242\344\270\223\345\210\212.png" create mode 100644 concurrency/src/main/java/AppendixA/Main.java create mode 100644 concurrency/src/main/java/AppendixA/MyFrame.java create mode 100644 concurrency/src/main/java/Balking/Q5/TestThread.java create mode 100644 concurrency/src/main/java/Balking/Sample/ChangerThread.java create mode 100644 concurrency/src/main/java/Immutable/A6_2/Main.java create mode 100644 concurrency/src/main/java/Immutable/Q2/Main.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/ConcurrencyApplication.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/ConcurrencyTest.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/HttpFilter.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/HttpInterceptor.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/TestController.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/annoations/NotRecommend.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/annoations/NotThreadSafe.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/annoations/Recommend.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/annoations/ThreadSafe.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/cas/demo/ConcurrentStack.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Node.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Stack.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Test.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/common/Timer.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/common/closure/ThreadClosure.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/common/communication/ThreadCommunication.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/common/state/ThreadState.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/common/stop/FlagStopThread.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/common/stop/PrimeGenerator.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/common/stop/StopThread.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/common/stop/ThreadStop.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo2.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/LockSupportBlockerTest.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/LockSupportTest.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/UnsafeTest.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CountDownLatchExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CountDownLatchExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample3.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/SampleLock.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/SimpleLock.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/MicrowaveOvenPool.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/ObjPool.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample4.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample5.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample6.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample4.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample5.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample6.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicTest.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LockCASDemo.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LongAccumulatorDemo.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LongAdderDemo.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/cache/CacheController.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/cache/GuavaCacheExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/cache/GuavaCacheExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/cache/RedisClient.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/cache/RedisConfig.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/ArrayListExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/HashMapExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/HashSetExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/StringExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/StringExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentHashMapExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentSkipListMapExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentSkipListSetExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/CopyOnWriteArrayListExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/CopyOnWriteArraySetExample.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/condition/BlockedQueue.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/condition/DubboCondition.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample4.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/deadLock/DeadLock.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/furure/guava/FutureExample.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletableFutureDemo.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletableFutureDemo2.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletionServiceDemo.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/FutureExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/FutureTaskExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample3.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/Account.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo1.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo2.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo3.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockDemo.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample4.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample5.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample6.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockTest.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockTest2.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/Point.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/lock/TicketLock.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/Message.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/MqController.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/KafkaReceiver.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/KafkaSender.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/TopicConstants.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/QueueConstants.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqClient.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqConfig.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqServer.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/publish/Escape.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/publish/UnsafePublish.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample4.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample5.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample6.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample7.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/streams/ParallelPrime.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/streams/Summing.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo4.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/sync/SynchronizedExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/sync/SynchronizedExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/HashTableExample.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/threadLocal/RequestHolder.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/threadLocal/ThreadLocalController.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/threadpermessage/EchoServer.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/MyThreadPool.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPool2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample1.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample2.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample3.java create mode 100755 concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample4.java create mode 100644 concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample5.java create mode 100644 concurrency/src/main/java/workerthread/v1/Channel.java create mode 100644 concurrency/src/main/java/workerthread/v1/ClientThread.java create mode 100644 concurrency/src/main/java/workerthread/v1/Main.java create mode 100644 concurrency/src/main/java/workerthread/v1/Request.java create mode 100644 concurrency/src/main/java/workerthread/v1/WorkerThread.java create mode 100644 concurrency/src/main/java/workerthread/v2/Channel.java create mode 100644 concurrency/src/main/main.iml create mode 100644 concurrency/src/main/resources/application.properties create mode 100755 concurrency/src/test/java/com/javaedge/concurrency/ConcurrencyApplicationTests.java create mode 100644 concurrency/src/test/test.iml create mode 100644 license.txt create mode 100755 mvnw create mode 100755 mvnw.cmd create mode 100755 pom.xml diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f4e3f40 --- /dev/null +++ b/.gitignore @@ -0,0 +1,26 @@ +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* + +/.idea/ +/target/ +/*.iml \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md new file mode 100755 index 0000000..79d2603 --- /dev/null +++ b/README.md @@ -0,0 +1,78 @@ +## 1 目标 +致力于构建全球最完善的 Java 高并发理论体系。让我们的程序更加可靠，跳槽面试更轻松。 + +## 高并发方案概要 + +### 线程安全性 +线程安全性，主要从原子性、可见性、有序性 + +### 安全发布对象 +安全发布对象的一些核心方法，主要通过单例类的多种实现方式体会，这也是对线程安全性的巩固，也是把线程安全性涉及的一些关键字和类再一次放到实际场景使用。 + +### 线程安全策略 +线程安全策略，包括定义不可变对象、线程封闭、同步容器、并发容器等，引出并发里的关键知识J.U.C。 +同时还额外介绍了开发中常见的一些线程不安全类和写法，并给出他们各自对应的替代方案。 + +### AQS +J.U.C的重要组件，面试必问考点。 + +AQS模型设计及相关同步组件的原理和使用，都非常实用，包括：CountDownLatch、Semaphore、CyclicBarrier、ReentrantLock与锁、Condition等。 + +这些组件需要大家能熟练明白他们的用途及差异，不但会使用，而且还要明确知道不同方法调用后的不同效果。 + +### J.U.C组件拓展 + +J.U.C相关组件，主要包括FutureTask、Fork/Join框架、BlockingQueue，其中FutureTask讲解时会对比着Callable、Runnable、Future来讲。 + +这些组件使用场景相对AQS会少一些，但也是J.U.C的重要组成部分，也是需要掌握的 + +### 线程调度-线程池 +new Thread弊端、线程池的好处、ThreadPoolExecutor详细介绍（参数、状态、方法）、线程池类图、Executor框架接口 + +### 多线程并发拓展 +死锁产生的条件及预防、多线程并发编程的最佳实践、Spring与线程安全、以及面试都特别喜欢问的HashMap和ConcurrentMap源码细节 + +### 扩容 +垂直扩容和水平扩容的区别，数据库读操作扩展和写操作扩展 + +### 缓存 +缓存特征（命中率、最大元素、清空策略）、影响缓存命中率因素、缓存分类和应用场景（本地缓存、分布式缓存）、高并发场景下缓存常见问题（缓存一致性、缓存并发、缓存穿透、雪崩） + +### MQ +消息队列的特性（业务无关、FIFO、容灾、性能）、为什么需要消息队列以及消息队列的好处（业务解耦、最终一致性、广播、错峰与流控） + +### 应用拆分 + +### 限流 +明确限流的重要作用 +限流常用的四种算法：计数法、滑动窗口、漏桶算法和令牌桶算法 + +### 服务降级与服务熔断 +服务降级的分类：自动降级（超时、失败次数、故障、限流）和人工降级（开关），总结了服务降级和服务熔断的共性（目的、最终表现、粒度、自治）和区别（出发原因、管理目标层次、实现方式）以及服务降级要考虑的问题 + +### 分库分表 + +## QQ 技术交流群 + +为大家提供一个学习交流平台，在这里你可以自由地讨论技术问题。 + + + +## 微信交流群 + + +### 本人微信 + + +## Java源码模拟面试解析指南 + + + + + +### 绘图工具 + +- [draw.io](https://www.draw.io/) +- keynote +## 知识体系 +![](https://uploadfiles.nowcoder.com/files/20190815/5088755_1565799768221_4685968-76a236d781f7dee7.png) diff --git a/assets/LOGO.png b/assets/LOGO.png new file mode 100644 index 0000000000000000000000000000000000000000..b5e3b09f8f5d2084d2ddf2174a370986c01ac9f3 GIT binary patch literal 100047 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 z zUe~$l%{mjxwrO!T|mqW~Gn)J4TbfuH8DkxS~4>HHk`nNnZLn zmYlCiveml#CWABrFgAIWtGO45ziqgF-h|Eg7FlHld8AW>XhnuUkWaR=w&;aR*<}UM zv1YNHTyQqzyxfyVo>M<+r;psRlK25l^UEImn?Rl1c&jWX{>a%uzow& zGZTD02k1=v5P}YV_d^>F zlj5%7V=FgE_#cI=?qCi9df(u4kKd@~vU2g&o`?ORXFZyayR%FwWy1VPMjnZmOS?8F zads||I*HRpKV@dff6xMS^D$X|VJ6@henQQ9zx;{hX z3V+n}?-W#imTSN;8_**{YM2485d2lPNN2RHb*qGeGT2u(!r5X&;cFB>kS#zh<9tFq# zE^s&TyN!8!4+rtub znv^kwmv(s%$F+HVPVIV_qfZV^HkZ;Bn2M#K!EnWW-43lA^)OA+MOv&{B1F#g z{2jE=sfFq)54V!BS^rOb>j}$Vh4sTX!Iv)*vBxtjD-i0~4hLfP$7Cp7DLUIT(n?FZ zuY?wFiZk4i=NhPKsN6r}Ox%!3t@{Ao+32YlOw8N}&s&VZ<93TAn?n;lPPWXFzV^~y ziOEK}SW9Er6cCbVhcH@;Z4krU-{YhH_ zi&-J1x(?=>{BSMp{CmxURh2cPcg>qm(>4p}5vl8CFZ?iV8xi+c+v_5oaYJiq-l<6H z(49U4ikt8+C9sZzbr!}m7QQ&cDj8>xz8rRC#gKd*dpiV-JDP7V=_^sov{5so6rxf& zZ}Rr#DT3YG#y*gOj=EsK62>N#JL7J#CLH_p!>qGDG5wv^ImL(h=eh{!LBWX zo6RTgCQ;UP{(J20N5I`J{djdJ`LS!P@*&%*O@TCxfR327cLzPScFw_UzIVH~mcsoF zaMwEzm+?@t)NgB8>;OZDOW?KV$vY)sxZ^%`(iL#)XEJjaCPOG*S5(A&aIYwL`Y0!V z)iVOVnmFvRZ64!{=XkLX*xz#$zmB$Jr=K$q9OgGlWrpeWCO{7g4%t1V+DiIA zn69&d&Apbk7JEf->eY@97)n?sq;m_*= zS0|u$Q)r`whbs;HNnS6BYI92}%Bll|a^%%L%vE2VK5uR=f<2U)(qV=+nOMUQIV=&rY$P#baoG%0;Mx{J33H@=|y zTuhNL|IEqdBVf`m#0_;z&aY^zyw{c@1WUNTRr-PB8I^7Q@clDR@Q<|9iSWGA_Ox+YD8xeXYU|wn87eQ<8zq%gM5x{sMwEIXS+Aqu8k+`Z+2cJ}9>w>9^YU{+ zNu(3|2pO9xFAcZ|-Ug#TH7=EQujY^ID_;6!C4b6!pkk3JD@1(=T)fHt9<_>cJYuK5FLQ_c;GafX`_3hL$|%&uq|PQ@&$Ud zLZ+uo>A5cw-o1lYjK7cPYMKNZb zO-c#2K90_V{5rBVf#KmpX;Kzu8{}KXevnY?-+h}SYYhUvwrYe(o_=kF<>4cCoxhXk z4L5Z)i_9mZA4ZV+^4;Dn_UhM!~F7xuwm$SOusLKqFA6e-AC&~GIgzyM=^WUvmXj~8GZ9QNZsFXvv_!n>u+A1 zuV_BUAdr#c#eM{=;ael7_Kcb{UR|4Vxb@*-NA!I=P5JH{q| zU3cdQz+)5Z7PbD>+_QPFhUvXgy6H330z9ykMw(J~<_~^CE;@a*C9MI%LX&>Muh4_+ z0^@7*OsV%D6cDEMDDgPV6|7}_tRLwjx^}}~)Tp3?lZTq+e(b_^He?h?6UgZoo3J6k1W1Jn4erHbCeFsK^ae;14Tv&T?lN6z~W;9c9 zuNDU`X4MlnZnbj`cRZ1vkR&zPOnCVLUI==Uu`KBx|Ju?tM_?_Jhs8uQ4RIy$h~mdr zl*Wp%B=girzrfqGG8ha5@a1O$kKj3W?5*#v4=8Eid@8%QbZBXw`M#8*CGpx*o6_~M zw_~Z&JY1PB;bbO}kJcne5l6tD;$i#AI?UC?Ww*cOIE%*3|MSMRvL0v~9#Z5sd2| z;BcKd#N40kHd65I5rc5l;&{XvSZ8k_OtswjG~x>HR>oe(-+AQIefCu`FPso@w+qxGv#(XNcld(=>Ja|`tQ9t72EB^$;zi&wb2=pJN!CM=hQCV zbgsS+?y0#l#9;mmMIll@TIhqW%3Fy0tp^3?^ zVB&RnllBoH9GlV;-a2Netr+5&pe9mAvk2d$8XR6by!?vRfj4KQ_YiYW46-&@m|j@& zxQ65QEB7tG$C<+g*RNY=40rnZaOsce)61WWIInq8BFe(_1%MM_)9h<}*nb4jOf>C2 z0>?mlXK*})pB(YwvAmbnbp+(VT<>#kaB$N7 zz}~U0*kJ|r`nra;1HOlw&dr8Wj*lEHgApA2r4L+(#crsmRQs9+esT(C-3U=W?P@X4 zpCblqHMP0QQdx2Z`98O20-%xdWgDcJC-D>3Tfaf8BVhB?<*nqjBjBa>>%%J9BOnsF8#+0Bos+jB=iL=l*6hzS3HxuPH>XL(}e@u5P;LvZz1PHZ#% zT`gBZ`-a0#^lrjMNev2q;7^Jm&UPX-u3zrk! zbmCa6Ou*Qepu2hHsV{|ZrxBH_%1s(}`FHM#jg|LUY)&*LK2C}O*P}$}mkzty5|YA3 z+Br0Ow`%wXb$jfIKD2G~#E_c`$kSh|(502c^+|_PAapO(Wxgz6i!<7^XNi79*gV5^jdxTaJt2;Oti|s z&9C(QdGefC-g+-N=T;Z%hEJ>ga4(jy(Z`c}M?m5}bX_@E9V;UDJZOg+o%U@wZt(s8 z_}%Z{*g&oko7`!<*BR_9+FQ+xHe2dEZ>UiBv28$@oO02L)Nj}%W&`Ws%E5hbwer?J z${|nR)sZZZSlhehPEl4WkI)ZX1f1_DWjyt~tc*P}pytJPd2^pW{J@WrLfvq2!0=v1 zr|FW2nDX-;o;^EOr9iutb2D-#p=hM^A*fo=E=X{tl?W?(GYx%D^{J^9sixu4TBZB3 z*h;MK4flhEil|VjU!l~=*-0Cvh@~u*H?Y+Z?T5vP*>r{y?F+3nc<40te)2r54&l#g z9ML-%eBh2V&vLu$jYM1U{^R_?Y1;d|4tK`S_f;F^a&8o)ff#XZvd4F3jLZ%2og=QF zEzjPc;AyRv)?vSA`l;+Lca~`(d&XNm>Fa*=$llpI4^Amf`ec|H#X`gM83h}wjg3pSWZ7J)qE**L=Qr;NX{J<5O`dGN=MX}Rx9ly`tfN_W z1jzKAHsmvCL3;;%{u0A=6P^4e@5*%TG%3mSQ|f30AK$Gk%}9Y9-ekngp4mPvEq*PX zUxR*XW6{NRMd24r4UHZG(IPkJ-x%cp=S$YdeE0TU5#|o-mQ(3@Q+{lgkrJ7Yya= zJSoJK!!|z=f)Mz3vliJ8u!B^@GnsTA9;OEz0ZJScg|$z9bqCVQdzRVrQ!k$_W$J`oS|r1Ebd;Ni zQMnhiRUY0wWH|y}ajf4yxUq$Q!037C#(Hkx)+wfstkk2ZF;_V?7ppIh=Jw}<(p+bp z2oxZkb-mAf?u|G&8LEh*dWtoy2GVdLYNmPCR&TBd4;b(^H_jQChQv8Uu3eh|%wx%b z!R3Pbg10$S6ZK21Ua|TY`@O|;qFsd^;j(WGzS0QC+NSii^?AoTcI$<5e$GYjR)TBV zv_OUVs><^NFWP7^{3F1$AXHQ^h;=ViR19zE67*cG7SqOp+@TLl>|VhF~l zFbaB)hb`P4^Q&i`W?zJC;?loL%m>5fyLVYfGa}XQFV4@Ej|;zHsdG}mer}Xgu@>UD zrZRD>{u+B#UXkZryGOnejZcYK zpmAPTOX%0-aODW78>rh4mE9NGn>u-bwl%SL00-ya{v9on!(`b{QU~xie)AimBuBt) zKW}guE@`|9+>Xxk`$SRefLPxnv!TVU7I2d_X<0L-Oe&tdP`O^&6jRK%V}7d?Tl#=q(yhv)s(r~FGvz=J%O^P&W`ovp@26}8KP*dQ+Lga<>2|njpg|Aj~}L9UvwVgY~ws! zqS)aSaOFpTncMl=$&jnLx2b-bML=@feR+4kOf1op#VZGXk2Tu%!;F>XjbQ=87IJE3 zayf9l3@xc3O3dvN=mdQZM|-zpFZX6-k9DL+sx*b`6!2NP4g$)K+J)< z3W9O9K{c3RkhjGaC!FmWZ0E(EKypLKtr?L$IWAUv{7sW6!ug57x9Y~ME&p7 z)8q^3yzlox)AzrZ(XM7VKWkv#tTh$9O?LTX=BjNG$Tc2 z-7jMt#IYJuuYIVPZnx=etfhSZP_?hX$n5+@t~Z{E#=z`De}Lfuq=1ce!DsYcN?h7< z_&vk-Ya`p&5EbjnOsm!WsboB_@J|kgZhJY2XqL6p?S$&pN&7;5TMmiW&csn10Zm>W z!V=SG8}Argk8-=6sU_8vFI0sB*-J9Lwr8%TCP{~teIESV(yYUc=D0b1ZXdv27> zk=c?hmDqjJzY|HiD9fHw`)Zxn<26@oRrX+t;-)C+&wVWHc*FdV%~A_?%S(O()vbqq z+*3x!GGzW-M(tusSf<*cDmVmh(01+|P4Abw8iy{(gV|{Cd5- zm}#zM&g(pn<9NT1<9MHuoanZ~LoXc^(p&tFoA;RLVJ)ktk^;%-jz1#teG7zwD(nHe zA=xY1M_KYn-uU2+l!)V^cg_RR!Y!2_RvU!2g#U)^c+1P&y+oplpGEF>jlNb~^7Thg z(jM0}%Xsm+leO-i-D5bCp4mlsZNe#>Rdd@ksWxlsvrdu!h(097FvY%WdVF?VFTr*V zAvAhLq^7;5RAu*K%Ig8ME{X}0pFs*@`nWGJn0XtpFIbdN~8*E9D}d5XCs-r2{v1&m~!QNXwxE} zg9~V)pI;&5WU1#ZvXRfz#B86KJfNsbj>KCj-~F^K(!|~WsM!2(jWT#jU{)KB|9@Bs zzU=fvYXpIPvfm!VsdJldZ>8B5_)`RHBbpI1LhHA#=wA(To#dH&8^VbS(AOScM)scO zL&j(f7(+e`_8PPRvj)MV%)hIr9c z>F#ZpGSM>l_)+1gPrYEFEJM zk0uDluT$dRnl5ANsk3p_+DoFAmT60;6Ef-Lqa^phx$RnHEZQrjDOAcA@Kczo!EB# zZyjCcwgxA~E?Mtp{WR6_sqVwo>L+69osQwbF88iCTPdrYG|rgg&de1gAZAy{GNXs~ zVD{RKu!$;ab)7~>JxFn8eQc_B?uBukr^%04F8U#S<<)*HU8ww2c}e`JOYgD30hSK} z*716HbgCC4d5UWBJhgACSoq^p;RVT zR9ak0yWZi%rr2{X=(F#@n4n7(D~ab>#hr_+yOhVat?fmS^jdxQ91IHaFmr>g2R1#( z(ED^o3Lb-1V+76}&1Ybov=eV)ogF+*`O}(D3!H%#BDaySnRe4>+`J_3#Ygocj*O^E z)PA(Os|F6gHq6zQz5)ddRiM1ep& zn$EPY#QhY=>i-3#@aoopgV;8anK$wGLt8I3^rAl%{|1yjPCy8RfGT_%z6T{vOxWIL zoiI^%nI<1C+$4T!(D{p@+(=+hmEty5g}Rtn zEj)lJySrj#xLecF<&l(qcM3oncifNtL0&^JL;o) z2Tld|5Et-}&)ubRK-%0b&fb|VjdK3@F7(Kruvx!yTDPpY1n=dN?v<0<Iw9vnx2r4+r_tTI55%>P_Tm0V=6Py_1kJdVN{T?yW#wQQ7C=o7-aP$nL zr>sE+!hFHk)9@XoQ|${`(l5JbO|R^?_WH6iBYz_+W$A?T#GCu4k(nn?WTP$jw>F}G zAr5n)N62+?B|XOTqZ_b}xL8UfPVpOV(0ayAX0u9VDF9Fw|H|k6<8RemK-`GRKPx|} z{%)u#SDS3yq<9`7W`39Pb_2GMWH>dpitQyMzrA>(y*KFWDT52gq9TXA6}KN~3uLTP zc*(m}Md*@krKa;o7Vlq>fA+N4e=It*|IMRqw2$J`(&oA&)2easX!5*SljulNK|6Js zju6C0XQ3ofy_kJmUx&D?dmbEHTpr>`EJtr+JuQ<@&?={2goZe2YGrm~ht8ou#WAQiR*uZ^r}rWir&WoD6NNfb)N&;*cbx%91$T%X9w>@M zBb@*03#+gYBt2O<|VCEw06#W?CrgfdbiB3;p0;P0L-6-Z(fFA1}=X=V8 z|A9V};>$y;EEE&=h;;hRZoz?L)}714RrAlbB(O06W*yCVu=&XO;Hp)z-Bqg+phb-CB1TbD&>VBR9a!f1FgK2|+4`X-M9e;}**k z8!#*}acXEkO3amo@HAc)&S$rOy6NZ%(NGJw9DGxN^xV`%ZvJ}g%TkjK*pA&Dw_-0U zA0jAbw>{1sYB@&teA9CoO}o#AdO!hE(8tK{3miuf9LS~*Gx85iwNoEpthOb6n96{` z9>X}FBN0gXbdmY{X#5i#`=`jH1d*ZWA2>GD(tHta_#J{vCt_zn;_;_!Y@P6CbL`>= z9AOyF4G;<&D9#>M0jO8lr0T4R2%ZQ@Eo{ItVqEC!T0e$JB=%rvd1o6$5+DNNCc^{S zzcjiRFQrD6^FFL)q)<@Yvb&DXFsU?pRK-MO;fP7ll$tL(i(VPcYSqJJMWn{If=t8M zA&(81xzGlzP4~Vr3UCrf%7UV>HV2mQ@HDNF6#O0c^*#F zK#DpwF>|VQ>fA7A`B^El z3G)ENZ%$Y2KGC1%8vm$ZlMs06SvafQ)rc|PCB8CIUbpS#YGhY2rlnLb(o2U&Oo!l( z)nb~#LlOCtl~{_psvtJxOZ`(D)G0RcIk=d`du77h#8#onbjfKX2Yz9)ZUg3bz|)L^ z%yhl6pI?J(&Ui26H^2YV-h}5BQW4*!uwUI0Uk{piJ4rS0a#{h>jb;0O_x*NXn@K;S zPUl+_`Pk#Vtaqk2(AwImPEcBXC|GZ2X=eaj-s5V2jf@UBJGAG1*m^-!oGZ$bs8dK7P7HTCbMF`1{8mQl`}Pma_!ZOQuUDVP=HP8t)uAG+DyX zYex5Fj$r8$l7VX--*qRZiUl5=di>;LPR^1QKl;u3(Y34PQA;;DOlpljOp1tfF(bbY z6a15poLvq4^zPtq+l26QTC=G%6*Kw?QU?W7ebt|QFZW=K%f1K056(PyY%k_v&*n-R zqqEca>Eiw)h??tpDh3D{ZBlXSa-*iPcEO!NnOSqLqa?KhgSZF8zQ!||l+Ww%SXbYK z2HEE+^l_?WH{JVFsrCr8kAl#SyGhne-Wi=%u{Kfo_~q`Yo$fiaJGE!Uxke<>%j|xt z>|M&%BieGN*Wat{wU0F>9RJNdH-RP1@Y!x`B@~3@1{+qPtHbREMT?Ga7c%Xwt(#rV zNeB!YK$8{6(H3V|Q1W~qG9R@@5E2fjztL_ezb-K}h09`Zx93F-C2Vb<4DYNsB8-1| z>7ep@{EgoRedWdLwP^Ku!)rsNt9pS3m%qJtg)|HNl}|M|$ZVN!I(v(0M6%)>Zk5hD zosTfCBpKh-HtStdoh#UYZ6m1yQ{(^46U15XwB0s8PI0CPNvr{@v1Gy#h>>N*}Kl+#>&SJH$ zp8JWL|2uxE61bir2`A%?FQ9@c4F!h!0zp6WCrI-43fmvOlJ=T-__c% z9d&VCeKnmjH?r`&59z;9Dq>^#l=`K!PP8oa#@3fnyZXm<1lXG$J9FCr zv}p9p$q2FH{+pwY(Pd^>4K0ns9ighPs(?*s;{}a9Up=tQOUXZ-!&62B4#e4;5#5(d zn4Zb=_7qo^S_F05eFTNw8SvcKemMiy?|$;;Mf|Dh(NJroM{BKpAG{XBm$jT}fB1&Y zYEbf*)&n`A*PD2}{e~u*PB?tBU(0!R#;smM??%KVisjx5zNwT zX!#C)@}cYZ*_+q9Bf*%ryCVHR8GYi&=uU}$JJ0-kgC6nwpr8L^(9sl8mfBNG$@dk2 zQ{Ei(?4c?I>1vkkIbS^<*DHgrygVMe6GZfXyohdQTmFGFr4y3k9a)>^c)AID^Dngo zuHQtZEuSReM&Zv;lGFC-6!EJ|gL}P_`t-+td^LL)F7tiWN?5yvdl>)0WGQM`kB@>T z)CE59L=x;G9zu79Lra9z*OFhcmxe0bUcWVr9s(;?K%s*vL=n^?=ZDplXKt-GRFt}? zdP7j8n@<{(>OtA-l4tCZycl|lVE;k;N?e(u*YqlsID*WxuCPM}4zZth=9lY21UPXI zjx=<6E+)}C`Y{VES1*OO>{Jjz_;)j;O@^cAB!*K-@LJrV`=krUzZ4bH9)8-kXZ$8w zo>k>Q%qytGT(Op4{F+vmt7F`yORkD#dB_X~YN=9uRcDohlv*A{vMJT%k{38$mSFtA zal9XMjBAR=98BC0lpKB@I~%%{*}`OJm7_|g`Y!J!dq>%W)&pWr3vB(WEZ))?3Z-Tt&Q3`K|d6{Uo0rk z4HyV*WDsVcU{-ozeGy&sYXAh`B|D4)oceDM0YkQB9=9%5&Xa`3_Au|k|D(x7{8b#K zzd{{qu3}tk!c8{*UE8dRGh2TH{T_H}t_6CkdyFg`vK+#$}V90A1e(Lni37JnUbVI+j=gTTgnJSfe zbtXC3%dYM(zHU6K7qRGI0f76{stwr1MC=>!Ne6|#jFj+bV^mGV?dyjkBQ)Kt;W1O z(pn>VWJdKIdAr=|8Wj^UA)HaHru-(HvycC+pV1aY%N7p@b6F0PQz`u=Dvf88udwbn z*3p>q4irtf|A)i+-+n_If7y!5Qk&5sR@9gBOz+*Mgx-Ht+y0XjaBY^ziP)$tN{CeC z|1`5tEAzi=7{MH#8axtoE>EXkqHtFD)k(xN#We2x*^rZlj^Qs{+~GN(1G4S~j=)Ay zB$UZr=yh;r>9-zbX)acM#5-UV1+lJ{ch!%Ca))zA9@pHO5ekFd+M+jy%)FYCxMN2< z9AEfA=<)I~HC_$jHF3Bo^E*mLm4~8xBH$72QK^=aY4GCi5hXj7|;ee5{<7|#qc!$AW^KG9m zwrE}(PG3GsIzM)Vi8?SSH^9rO`feCsL}#N+V(EN%di9XUyFp-VU!&IS`9aUMdjta$A39=~w=yqUTm|`SHPg&c-%^bddx)|NVdx;mcFx|3Hn4LbISe9B zjB(!XzM;1_?Uk$SV$_p+;d%$;N@8?2+peDdvqJBG(|=$3_Ag0c*%0?Dm)fKJ-g^I* zG5g`kyI1TV-v1$tfNclWRV;No&w(;2#iEF@7%szn1J}L2w=n`^+^y}psK+LSsBg?u z_B-hhNbfU{cjdY4tmLk+M7t_`oAv7W(Z#XbOu|3jb^W34y-HDvr1lZJZBa{D(^kBb zndHIyrqTX+oI^GlX1aD~h;Js;La0aDEb^q+uwTO4m>!X_E?P_W*;8u?0zE5i+w^Zn zyIWP~=dx=bdlHN|V<#tT9A?zgEwt5ZhnFM`>560?z@ROTO1-a_y}d6Hj!W=qMg(W9 zEJ=6@+j@R>n1wEme^0dl@-1^h%;n#u7q@!Kw=wyrOeg)FD?Bm={AH^5d+$;P(u+$% z!HGNpMpL_o4aHyk%I~nbG->yXNa2f+2*ODR2T~{PJ(On`Kmb>TPl}*_# zZdM(vVB0Ck@5}X48sm!V96`?{%sV*YtF_Q7AAVVqv{0dBU4`C0 z#boVZp{ho0twwT7Yplamy;lM)`UjKxx!t`|la^ciM;98i?l3T32 zf5G(|!{ax@a9*NwONCzrGcxegb#ppkWpN@a<7k;YfV#Nx&DU=qkHuA&#&c*1>GRCh z_CXx09pC7IJmDo3_I*#htU_WJ(K8z`y;8vJlJvS;zaziPRFbC=yB0h(r<55USEGDf z&h&3N$X-FOqTu^imT>J*#p{SVH5H>Qs5TRZgn!VeV#sW1?!v3U|lH(-Blj|?|p zc6&xYpxRJp-o(!)?D8*&c*p_KBs`b@CB?tKx8YK%%W1nCjL8K)8Q&1T9ikfc987y- zX;8J@y18XGOnfbK6$!|@9mB2EB?MKLNHWH`qjksb-~JPz>+P>f}<(uHaf8y zvvvs@Vel*%{e;rjigDW^8|=EI#aVC+xaW5gPpy$v7HO@n51DI*bVP>oiT|)U%H+xO zN5>x9P2A1?i0%#hfAQK3P=E9b;9mz{YWpGps>!v8l}S7BEd+4a#EH_lVaXT@oF5p2 zmb4^#*!nlXt?mOK^QeGUR@}giYa!$N*sCxvEl%brVf>UOGwcrEZocPn?&SRO!9rn| z+F)sEX_*AOWosrYILq-h?+qAnW(mN8&@z!#b}*91BpJThxaD1$tyn)Jhbt1xswHAA zR?q9F@h=|D_mqF67XpDgadHIng$e{N?t-L0LQ@QIJcucEK(vxf0En+8Qn`}ynKk}P zGT{DRMkASCl4Y0xi!kL z*l-R&`Vz2oa|O%@^Y)jG$-5NOa;B{KJj@OSq^Vu&FnBtEL4zRF)p~kz#-4ttj;Ybg z1JKq$8Z#&yr$JmwX6^>l<@jVU7{>X|4VXp)GHGRH-Gy``V?B8l_F1Mc&h$qL zjU~8Y6KqDbIWLLt&+6J%fjwO&B7DEGt~2e{KX-OH83|;l#aH@Qx8P4pmLDc62`!X4 zebWzCr==@j{7!we7nOn^(?z8N`Ux;fMxeG3)elYOW3|Mfa;;kO?4hQ6Lz+05 z_QaopA8Sp{Bw62dc&!GlLfj+c_7mHSougB0Goc}~~v*Nai1qko-p2*M@$T~N-? z4wh`iO|S-du~Qa-E4ZB7^yYO*N&r|8lO42P`Z81*MQH$yM*=vo;7hPfc`f=$WH4s= z7#IeMIG`~{of&)DwN_6dV*KeB!0V-HuUV%1ujkLUM3PK`OHY2GB%jB%ufd3;R<(T~2K8q6v(C5Papv*VQB(@+B-)^5Bf) zX?L+fJ;U|SNo8Cklio=b7qWP@#h!wv;X^tlt_17xW(oh7Is8{@dDgH>*q!<|Us}7T zj6*JJrpVb6Cs4zvTI8a=057Pwi5{YwNO)-@C78dwW%Yu|;dOvMR1II~2G~gQ8^#}* zuSbtJ2}BHlNT);8uJIT}p6ousJug9L&jzv$Jp4{g?~RRlwjU7KC76gcVSI+hMoRUW zbNtUSHel}5)q$PnwP$eT5jra}x-)L}H8Zq$svVm?(*<8}6eSfbUZex_|99+E z@$V0cv;i9t2G0(ovtYdh@BypIs0d@1`v#23I*+3az)7hnX{gN~aI?eN;Bke3us{R; z{SzQh$Opme*3`A!b-*J2biu*_k17j6pbXThte<*wYAx9NJlohovqt@ZE%_HSo`&yY z0hHQu1Tqv+kVb#qq(|Gf$pZHhBY0oeMk+?AFprEX70&8?dV4l1j)o4j`_EhZlp6nQ z2bxl)t{+JwZ%bR-BK|t&{A8moG`46XHuCXfH3(*}g1*XsYWBm`T}8lVPb-k0JIDoQ zJvJj6C+?LS->oQ;U^m&YHS=>~qxWyBNza7>Q#oH6&ukg)6hCq;-t3VHZdeXfy8pYn zCG=l*q%RL|8Wz?$PMs@SM=IVD$%T0c{(ouTkrhM$WP<_YfFJ| zXWQeM7qv!ju3M=-xWE;&91r(fEqX7&z8*o#W3YD_c7%2bMCn~E4Z6}f@4Oq=-LJV= zK>M%0MJdYvE+of?IE=gB7f1MC7794O`^KiwYtaX?cfjnCY5~i3)6>d^ zAi=$E@#t=0d~jA-@quzRg%)WT56_*QnvNz{;vysO zU08GL2e)=;%(u*{CDC%W6`0ZxmC&c`GUr`|upH#NS$#5B6f^qsz^M`!uh&${Wj*SjB8YLp*CZYO?pv*lfYs$Z!*D5e-zmtN7{#iuya(C!JTwCnAfP?~|Qt zetfRR?T*>!*yOz1L&_r=N?KFJ{Fyxx-G=>A15#m405vKTu5K{1KW_9H8xqHlo zCB*&@*dOc^E8H{8vMBIjP&R@xcM$h`ArRM`$2+SdJUv!w!JPy97m|DkewJJ=3Vkp)cs44bd zvsDP(mMS|4S2pj<)`$^>um)j=v?qLx34VumZNP4K&*QLRt&;m62hHjLYbHa=NcDEh zvJRaXXns;%(GChk6t{b^p+ZreO4hS@lFt=rFU7J_E;>Q76g_UJQdM_1RN=M$#NuSe zG2&X>_*eUHGfNH}D)B{TC926Mn|q|A^Mm>Btd`}`E&P|A3A* zIIVQYwYzR9JH!M3jM;o7rw6r-A~%~q${&*t`1BhVdr`dNL(yeksftVIb&BYWH*Kp% zX?nSK^VZ{ObPnVr~@JDls1$dfU(-7z%1?fA(io1s+v2(Uj`W$M?YfA8Sj)`t3pv-nFMgD;v8 zw$2g&)g}W=F5^wf1koX`7QV{Tg;;(|T>p-p!T^*Oz5(NgzQeBq-{pdxypz*XE}9VS z2UTRv;EoUY(;+~@<1aAp;8J6mHXi}D9|G8ZiIZ`vCq|@y9hD{-P|~&mE5NOGq|zlF zEFJCPL$BraF~-|j>DD0Q&PySK>}4Os+$l*hnFB&#Baa_vK6>O|eYaHW<=2y9hu5+^ zvhhndTWeY=w{d9r(p(yFNq2zffs?8r0mNj#9vJT$;J_HkNk!1-lWqwM^b5++eMT$& zZykf44YarotS&pe58()gf$YfSwjZsd(`-PH!i^&sOF-biLq83ui}%~m^t;hi(`6Rb zD4M(myqBZ2nyy~AivF!400+PkI&NM2c>>G|vMKqy}iR7aTLI41B; zQ=Vn;8ncDlUn^5(ySjT={RO{26P)Wx1iRbZ z_d*D7SLMDdnnc2v1GH!@a^4DJfp+7j2HJ|s5!y%|)6DpIj3HG|vO=9rjpO7Tr#-O? zp!4QgQ21uG@DC_1_j@vZ&0;rA5^C5A7(}-MW{CS*G3^0@G&+TzFdt>i7f@2ya~BIn zO=i(#|2hPxvi8Wp&OIkOSI#A$I-&C_)WkN_gwF{Jk|4jVlse^%$hb$7?F7mi|CM-~ z8qEgb-039*7lPo&REApfF@Q=6Vsb!LY;<6%F%J=d{^6pFuZ9Lu0V+XpOzIWjedX>nlp^>wcsO#mVYSri+ObCjb?wF-0CA<+|DwCz^STRx3!lp zke3oft4Gr_oagQ?Bmq#s`QLd7hsjM|qMhIK;g_%GeMZh~Wg};#t=^X6YQX zY>A)oMS+F*OO*k&8B5tSfnuqH7G=_>a6%|Ys6rh#Wl@AFj&8kvjX@xcO6u8EUa^ta&5qnCK&2==XD#4d*TPD z@0f?H;*U2Zhc?)>MSjd48fl$!WO9KlDOKRCB%KF@x#UI!;fd!l;Mhjhzzx0yp*0_N zGBgl7mkynbrmJ596|anXrvI;>O8)soOxLMonk}*sPG%DYvH0YgAe9eT#0HW-(?4X- z25je39Q{eT0;7Nq(oY<8;m)%QdtD=RyXPZJ3!)NpOZ`U9a~Blu2&|n|^Zt4$_%7O% zo&olCiEVuR*v_#;Vp#0DEeU%htFUC&8;rIPZFEKcuVDW=zzx3^7f|UXlmm!_!X~Ds zbD7B)x^ajiYE2KZ09*@J9K+zwTkl6EA%7tV$~~l*%4j@Ao~aS(1)l(}E&I?kxIF0Q z1W0!{!M3UrCF%Lt{^2v#krSKhJ|D5Yi0>wq1xj2M>9U!5VuMFUt^vM z)ymE%$0jMfen~_ zh_U!ku<6scd;FL!9Y?icOdg?Fn_URfR=={~UgkLFEom=ra}pjz>Edv9{CvS|*aqwb zc^GtGOaj!K>S#jHMG;XAZ~zm**Uff8QcYytV&uulv~~Ey5iMFIq84|;i~na-k1TPf zXw$BPL_;N*$0hw6u<5f#1MwR$Hg}8^p@257M`C^;FKlbwfekskCo}yp_w6o;n*;Sm zMmMg#zT*npr!7kZ`PDrU1a=1d5iaK5Ifyb2DLa{j`P3<$Ou;%X?>kO#y(j%5O9J}g04YY7-Jt)IYt3MRK3<0;`Ul$h3et>v^-Tk4gvw5rVeE}v}WKjrMUvkN_&0rp7gsu{kozcHS z&%zdcrwcMbj50=0wghA=81;_(nUn5R!Bw!7B3^)+A{TH1?Ii45;%E-CCOQ+5{295X zgdm{D&_CF}Hvtl+3R>v^LFJ`!Y`XY3?w7ZSk1>_#Bm~CQhe5?r#@BO6#8p6GLZM2vWq6pqL`O~mR{_;f5bUnWqdW3b32zPX#$RrV^~uPlOgnHpzrJJQY328u zprGQIN&PhwIdSQz>rcLTD01yI{EA;Cf9TIO+svhvcFuyO`mcWP|K;!hwxtkG4RNdF zt{v_OD8D~wGo>18EdnAb&h-UkB48}FdB}}xh+h9invr`ioYtiZMX2^yrFu?)xd<{F zDHj>+D&j9F$xk1kcwF;W+$&Os3aKCWX}DOYx=q$}50Nmnfr=s;T@Ik4uES(Xmbu$q zhAJud@ahM=^*a0o;5<=RA@~jsqXBtcT#w}3a+cV@{KDx0%Rte{+>)HHM%%)5&tl(= z9v%q06i7SRzj~Zfq*7|w^x^*M!tu#3v>2BGlHNa(gHUzI?bH zvA}5EY}`#`gat4)Jr;Z&Im-@v+G%)2f$fFQku90teIkqv80g0wvqk=NkRh|a8XPO_ zsTgY3VO<+((hHHQaEFyZGT}aEjX4Q07>M)y_$fJHs2&~yxC+Fgi?Z-uZp_#{gL<-^ z`vXcxAWf3V?J`ow*zrXV%zhB%)`ND9eV)MJyvq*&*lZqj0HbGv^%iA#tgic(@{m(e zA5k^s+kDPboaIAAg1t(r9p!oiqw)(ZkBBZe`CHD&QCWd#D&{Nvpy$!ftc6metZ8Z8 zr~S9`@?%{JL0wdZ>GmxqMWd&IJ$$`@**B`4K5(Yu1NFoh90A7 z+zWfZ((oL4(N6tns% zUBeT&Cbs^6`=|nHU;_sF7!PDa!z#ec3E@92T}CV=j}xt~M}Og2{hrQpi4u$&gzo|| zO!j8+H~5gSVcpy~$p>6<;U8DLw^WrjuKqtH+Vml-9zY^2?0W4VaA=g0L^1$wO+Ya~Yvk zuU{jCH*hPYA}U z&EhIkcC-q;lEXBY=^1v(W~pteY~3v>D+x=DwYi>KKl|iH02tt=W|`}$P1?jCD-_7b zS}6g~!>i%6KpbBW%CLf;vB_Pz5N@nB z2cOmTSj9f0I`OoAUywXby{9L$0kg(tN0)hO(RN%~^gM#ooIafQBy;(US;5kY@*fr} zt8YZyrIry1l-GyrjFE%ZbpX0byeXz|o}#q&%8F~FVus+%R%Ead?K#a#EgY1~2|p$7 zeSHdN=my%Tj@yx#rF#jewJ}r#;m5+W@Hvt7qoAClQI#Z$)ux;uo|7M8ug0-cWUjxy ze=5%|Y%g|;QIv^|qCsO*!Z{!0d&Fjs6yi_K{ub~Z1{tO7m~WK0J>IctH%s!oI9uyY z#aD=%ZKVD`H@rgsYIw~?&&Jk8F>&JqLqAYz?MN*0r*i}U3?vc3s|vmFZ+h+Vrt4(k}wy$+9spmNr{e1k=~ytMdz6^{DpZB%^w+_!8A^{V<6*u`Ftfpre##{JL zuTf{(Ev#3|kb-l7q8G5*fDHnhJ^Z(h(*lPb1#yB~^ajjh0h}Jy`qO<1Aq(JN8&WTZ z>*_eZN@g4?8l|mJN{na!S(72k#Al9)5ayBgd24`JLHxItkLiTEku#JqdNLpzzQxZ}iLE{I`^Wv>|LNd zf}SInIt{=?(_^-jCyO0Rw`gMNVV9yeCz+R4O$a{fHp0MZ-r z1y7I09)a*=fO`%HZ?-95*>Hn1kpGI-3ovFsNa-kpUaK+a!Pv?tFdhohz z>lFseYDx`flu16fDnTwQ@L|gJ_9D;dKnMDpK&s~1=b{^T=r=}pAqKJiN2u}dZQ2Vg zNtpejmw0?4`m_<9%ZPJe5huQmz`dX!^UQp6ySy+Yu018-61rLtWwdUBY{!Mr*$L3g za=s!GHfZ+s2JA|4#a*FHaje)>qq_LXsq?E-7ZE~wG#H)#wXtiS*Aq^a{dy06qaJ#s zH(>|b39qFaCa@G##^3g>Bpenf>(rgamK0Gyf*w@{f!5qjwD<1Ge;K>2Qu7$m!1G*#lIwCewVL+|4Ucp1GC{HoXEU6z^EIO;G}|se|0B6yBu&C z1fE_}LPG-|HVgG7uey-zzcxwkGp86+ndH2H(+2wPWCi_Q!P!HnMX3vlEq0@Uge=W# z<4qE+X-$qtu4jmq!F`#bb^jN|2{%A-0_p%r)XD(LS_owf$QO0Qm@NrnxS4~eT7zxr zV~kQ-X$lm{(a^;AGZrUtU8lx6MqHB*8(au%65J_VTA!j=Kgx|g{OhQcHs8Bx?97*( zvs!wtR^gN!>s!{WCGjCWxxejm9ih8DD!4z5y$776xA1~z(hPqQSd~>E=yMb22i?Iw z7vL{6%Y3UuG;=!o0atYD8T#6b3t7vzwDJ_jIW1OYGDi+0IbD|!(d)TOGQ*Nz;T)cJ zWDflbj@KyuyjNZ&R|Q!!6s4;5*u?k2c=}(Nh2n}$PovXZJ+wZzIk{@&g}&YUl%!d9 zP$5zb{gpNDN~aU!cq6~Oc3xm($AFr~UeTP|z;j|BVC=WV=77oy$NlVCdeuuxc=m05 zxh&4l3}noX?r&vLUkak1oI3Mch*0Px>&xU*)d|nGgxjspQmRHF%Jrc`rCOtB@7 zEs&!XBJQCNeBCwcnP(oz;AG^XRQv9m^0!t1Sfn>$+m|HTl>$70K+iXyv3Q6td0}6@ z8?6c+$vHMbi8?7}mq=ytFFKWO`1*8G?(3jVT+w79B*%8vBYT zSfPrT6&5OAdQ|ym1Yoh3k*=umiICm2o&v4M;>_8SHFqm7JLM!BquiO$q5Y)Age{j4 z_q1_3vQ&&Ko?t)cY@?Dkw`Zh6Y3`89#}6LTc^|I}u6t>qrcM0mW{iY#UQg@r!KIq~ zPW2C_X;J*+Dc&cmZ;0GJl^y&p9Eg7_)=E3hPH@{8`JZw@$P@VH6IeKAjP#;1ZDuf2 zs2zVZGIPcB%Az}Q|6Dx(JpfFmo%jS{*IiuJ;IF=z5b>K0`+r*Vzc=jvyH!}#y#-j! z#rcJK6_-_QzSKFT3&iuG`r{MSCd&L7vO?T*(8HyB5~2tS+V zprJ8S$E{!Uw0k-7=;*GRWv!9kx31mQ-I;8uC-C1eKv4$zpE8zGI8~R^a{+k))eW%F z;{+)%$4L<2yOzp4QR0-(E7r>vI?PEex)eQ(=1k+#ASikX{%<|=k(8t$4 zeVH~cjx;bsK4kw}@%l%^XFCDxAHnpVzhkz$faPHSli~QkHrm9Y{~(rd`4_Q-(&>uY zE0T#Tlm{1VJ43EN6pCHmtid;U0O~1V|Lx~L?2@qc53&gN8}3$bw=;sr%sSey=Ig5F z8)&wBorZkKtl}baRqMLwTKYJq#=usjbh(*&774oIcWyJBRI8rZKDoCHk3)KzBCfVx z8et0d=M7ciI7~$b<8;c-uiWP|x$kbIqSg+!N|~s(Sp-V=dDSmBH?-o z2mPHb*XNQ_6L=)j!Uu2XUwo6yu9mj*qfPNcW)5VZYGb_M;`Wrtp?@Lu?Lg?(4}9Ue zs4LOxlxdBE#@C7OrwgbxjPmHz{<4Ab{*MkCM_#);RbYMRd;({Nu!eg3^(aPZX)jAJ z1h|Z3ep!$6(>Z&)Szo{xt>pmPt(wB?W*2DZzI%#wc2-*)zfeLp>ht_oB^-NZLKMCB z$7hBNo?;6cKHFQ{=9!eWKLtq>)Ixo=fTIQPk_ic!JM_D>r(cH??5TIw$>&b2hr2Z>{9)apk!wc zC%4(KceI>ZTxHOAl!#EcC*P>TH7+4l$$Cog(%Ea+U7pBSuATpWke8F2%E7bnrwVwA zz6U!XQuJo(W&=h_paXQ?&gHq`f&0?mtfkksIfTogbwgpQ8D8S#)$-?zx2jT@7piCF zkG!62%d@&J8RjOsrSURs#!`qpptGe#d_p=N`dsb!ZED%Njv&RCrq+oPv$>4#dun zhPckVVJR*Z#vMDolz8kW*C#|>DA58$%Uv4+=~6gxn!;$te-Y( zys)V7X&I~fs7?x~c-IQN1o-I})pi;uZMW$c_>L1%{#;6VT|QHS0f<<9pWR^jEe6^t z_q`{K)UQxA$XntEU-)s6Yw7Cyatxp{zAN+vn}pF9s+|>c@?x3R>lg`CAJ-oC*)^!Sq3 z8%g&nxNijqYpJ|3!6P>tbTL4M0P#O61ev`}4qv9vr>`LtM^E$ASY}qHZvPmShkC$3 zCE<=jpdk-b+OoX^^cNtdgaK&*y7~Yo|J%cD|LE!~gU{KD0G_5A(d;2v`ge~)&)I_L z7WhA@+47|oY9Rgj?_Fqj!8efufBviKS_Cv*v;U*%8j<(GpRP`?`%G)a&y0IojoR;_ zBibG*>x|5)sVG%`zgz16`cZwLso+}YwI<*h zj&44(?q9=HBKxEBBWY-@}-y<2myOy|*w@{wOhz~c3d zAm7uEQ2DAdA+FG&P^a?j=n{{Ceh(;&I*WS zcik|06=v@of2N|2YUGK~k*TS~N{Z-2SKQbsxHaRWn#D?%wHKCo8%+AwUiF)k-l&9~ z!psN3Kmf>)vZfoTi>r%Wej~xVlV|#squL=;c;^mlP~5+`8<73k2cfAGIH8{>$2BfQ zL2E5}`eDMcekN+!oO~B)K5kBtcvbZoel_QilV5=>gjK%J?8WvJdoP11*tD#rYLq(Hf zA+JP`0^TacoX|3*FyrStq+En!0)!&MwdZZ}mhv)+zI|Ik+-iEfzp~Aj)k6cI!#7|+ z!hUReanv%iX=w4cQc&}4@$mOnf_WTADGTkM=T(Xefla2u{d9D4t7WR@oq+kHg*G>I z4zCBAACHLW)o=!o{->2aeSab{c{|3EY+m;~XT^b2Oha5zE^oe-{olYjLAJ-0SgVAo zX6Ld^kmC+|tRzV+EYtH9brKpZv*BM&WS>an_3&Zr=2R%deVXzq&j+qpgL zP~96SRJCYaQ<{tH7yq%oqAdzkyaBh?{i3EZG8@f;AW#*3PhX0a%>_&%jQQpRAg*>W zyD@yF2kiMnqF*BQbAx>SuWA&-o^I7*Ol|wb{@fxLKF1(O?H9LE;&=faGBY3hKjgh< zRFmJnE{cL8D4+<^grFcGRY9bPL`Av~L7E^$ML_k6e?7=b~^`!e4-fA#r257n3-`DwF3J{@FB3#H^+ zEow#qVHRZ+mJx2TZTdf42eE)Jf&QQP68>q4a{r#CXNwQs4u5?x zO+W9W2h?~ryfX9r2}btXE2yS2WIPxiAggAz2!|_)-N=nE_KVwQ6JCtDF%@$bIwGF% z7mW{AC-3kle)@gsUo`Y2l6d-1HQpJx_zYMOg} zBkpvV1oz=^ezDnui{M+HHn_OtGA$CHXF|gp>FU+^;td>jR$-_*`Q5a=dFG(zCOh zPp7K$KtGa(k~koHnn|eLLEE4r^mpH+cE^q1pmLxXXU%_XQwQmX@T8RAaJcy!#f0FA z-#7|e5FF%!y3i~m0$oTgyU%Yjry;$_vjnF`6d!Th=~lBMWwYS-Ol)TtD|%nxcN6f< zZ=V=?6O*R&jrEP7V6j%yeDuUZ z!e0a7a!almm-bd9~BJY%z8@%$4~(AKwUtdj<56B z5+~;7w_Ir#Pc`@Dd-=SIp)1S16h^WHv1SGpR>|hm{SMQodGG4alGi7?iuv*c{e1A8 zR%V5=D|_UT<;4B+*#a$~wp6~e65r$3wvqla{mEX#C3^awTW}cBbAN=m^>zG8K^G;n zs1VP6G{Vu6`trejil*>X%@J3pgI(C8?I+z0p}CGGnpu3^YPEhS+Wp%9wLoQsI`qvO z)LM7=I<}zjY)mWU593fs3*da*jMNX3xz(L zUhdUlmC_1xfG4%Sk8fS}!6XRACWBQ~oKKSQ>U`BhqZ;CJJJ~0eN zFm9gaSo1LmlTDA$6q#44cw+Xgp+aMo$NDa>s#htSahC!520-HNS4;BhXK?F{U6raZ z0fax0bER8>$~S%xFu|X>)<@o7etzGzo~(I(u9&6uO~VJV1L!OiNZ68}_XrFriFswt zp3@nO{lRhbw@)6>o9%6BpN!IjcL&-K54Vu9S`Unl!vX+*JlPAh62P9-O?i~NJW+?G?wdeC^ib?F2 zdGNm<-+dz|)dQ$p4mdx_@nVO6S}ySA|Apt33!bq0KVs4U-V|qp_y6DB5Ic}@7OJjX z)Aar<09xGK+qvxtWkvGaL)ohBvx!@cXUE5;3pa9VfQtG_KMhkw$*3<8h-=apR-Rg>|cd zYd?+x4WJQ-FnGM>imzgSur=z6&4_w%^H9c^?o@mwnF+GtXGTTY0QU9>>J60r>hul? zN+CND@>j*aB&5Jg;$78Aa3cVx8U?MBIaCB>?5Lbf1(*^P57}NZRN=F)rsoY*=^p%$ zf~HdCh`kg{9;$o&FPZ}awz)VvEg>w$yz9Tdh{)ozPEst))x`~`onUH2OH*}0ezz_A z<+t=dECjUENET!-pBzzz|3}HQ+?TrJDfJ$gjD-d3$)86KW^z^yz;Go`J*sr84s-4o zw8Uw#$I)4aeO)5_U|i6wAEKW%hJ}b=jOmk%zEwP`T<@|p(lnve#qYl(UUi~LfpMC! z3w*2a_=~32-~vUgf$U3qMWk0PPaOXh7i)ho$@=*0_!#Y~HqNN!>s|B~;~{jmWt{?T zf(3BLhgD0rP+4`v3{u$NeqnHT{BZ|&J>|lk&L)^ja={3uGydlA1y9y7^Tr++t+Xaj zj_Z@r|9f(lwDAJaY?o*(r$ZmgZMR5oYr%Cw) z`V4eT)o!Tu7LxnlXD`XgRe{>^pAJ&um=JoVn<>pIBW`nJxJRw9IhZgt{R#ODAcM-G z?~P4~!<4A=RyUZGr$&RFq|JxVAgf+HM1CST9XYCd#-vHmvIZwB z)5?dL#gPh8`FP~& zBVy%w3-nkm6D3&5T1x5mcOvt`j!?4n)Of%^ll&+@U;8S{;M$ht;E{(}$bQKssK8Nq zu#8l}!mjaM|bGruZsP{8luZd=BOJ7Alh{_ zD_a6|~QYd6`+Z%FJ~U2r+cxX0jk(`shHu5y zn!R_PC^a-3-cg^c6|(xCA}Rl|B(Zo8j+Z##a--4w^$kph+i~m0<4)h&a2(z!)03B0 zO|A+as(r58zO)#!l*}hnrYh=ps_AA;{G3fF82FlIOIE2kgi8jK?r60CLTKO> zjg2h}8=UWkoZhhH){QTyqOtb*bno9M{p>jh9UYY_J$Xx@x~OO9L%~WcB?yG2efD{7kzDm@H$W=$wtm6M?Zlpxf63@9}0^8f(7W8lKSDoA2y@C4NZBcHD3I$Wk z;N`22AN-4^DOt=R2$LDoHDY)uIcH;1_f%1%Dv0MN=j{-3H725ECgWa~V694)p5_y< zUvT1oHqBL>0+)7fOy0oTUzx@|Qw(6gIS9|jmCsU~R5-W?d+svTy=K0(Ve{4LlP4vjEI&~9bL=JHXr!-FV>1p9P*SEMMa!R>Z{0&7F zApw9OMX-kA8J2*`SMky71Bg4QlJC+AdeUzhkHYV>MURFVXMB3Nl#f=;*{-&X+Lyno z>LdZ}#*@3Vh6^;zFRRBHoeE*F7N$8i5UYnV#lyx>Eh@jDCzMpPRfXfdb5tqG4!>Cv zJU>2X$!)1=A(ieKW~Oln_mE*ML7(gj(|G6mNZn1-@24c3c*!aRj<9VlyYl|7v$yYG z33-pAV}vr!zRYTFFA|fV`0B5ojd}O+i$n2|R)k1B>}mAB_XcI!Y-pMoEScQmAnEmw)Bfk-{p|s^ zMqL``2I|b#Un~ak>P=H8@lo&j4qCV$4s0ZFN}6Qr8$?d+eX@(Z{#uKwqCwCOKc*hrL)#^pZT+UOxBFs=N^Jng1fn$tMu~u`)-rM&lx*)t{MpUc}8l zB$quBGPHZ$rNEr->;wn@JVfho`(FNf>$UV4`mg!6hOZsu$EHKZxK!DU>i=GM_}i;@ zr0T=EIJ6qO-M$9Q>bq0O!76` zGT*ZfXEX#w==U((*=cejIkL}6vq6-Y4czTN;KlTpm4aW{nH(KUw57Yqy^rx%mc+}w zLuee-%J&6jy=tv{-E=P|-QxfwL%6;FC3`L2Gf@XS>R|O+UulU}xis9aT#nEDR^%Ax zjeo!MtdMyt$y_arKK=0oI2Z{A|9lBL$aFe*ujb4Xd*i!wawl39==%yWhIQs@b6QK? zHy+K4{_YH5)a3VJwEEYr^(_?fD(`Y}MEfa#KBGDFS~S?|l3A)izynMw0yT#TI+|{% zIjw@<3=%IjyMyyqiP01eJzOnJHS98PZm#{s)iDApQf?ezXMfn(PFeN}wtpxYCZ$$4_8C8YAh!L5F-+aq!r zeokj_d!IN~v5)p4r;ES%J~%T)-9;H5LaUF??qWKo$6>P#FOiZZ#Ne!kFbVJba)Qhk zHram(_jiI(Wv%O5@ND%z$a5Ht30Vg(nKMJ`6RSzJq)@Q z4n5LiM~WDCxkwSxR*s65Bs;;S5Bt;q7`}i0+DDI)W|PqDwIVCZJaN)TZW8-dJ0qs` zcioj!o;6xdzQs&=^;$j*Ii4F%bCQPk2m3b1x*z^6mDh`w%4%*6kuoF5M|v7@zI3?L zc|B>Hfv(DJ{*9VZEtY+s%YtLHuWAwTu%14MQO zRrr-CDH`653Potj)@j(gl5h%7a|%WWe|f`8 z8kHWzeHaJcK8D;2dJ4v!5X|3~{{)+{>MWFj7}ml~$qG^udwvv@;WKU-s^q7AT^^uu ztOaQlgc5bCF5AdAOX_=QEWO0&5~J~+IN^G;Fl`jCt;AEQk0sJ#>AlL+)!#HaBxffz zf1i@CV_&?nK+gdZ3eFHi|6~Orv|%nV=IJ9M-^v`w3OJrt{l$Lm$`r1XhJEx_&(`nM zWkyRUniX@0E<e29;Rw#yI0f2U-Jy zR6vO*wy^KiL`+Pz=dhDSvmyHwLWO8E2L+iDA0J`xP5;)W#L$WW zYtzkVo^DK)LhcahYjp~9Sz0rzRzNbv&Hi4x!Ae!u;0g8&_cXhGQ@_kSZ%d^M#w2RD zQgl(1T-+U$MC-A#m}7PFTaQcfpS(x`3g|U(9DSV>C?=n|QE=-CAuch_L-G5G>M$k! z3(vpc^-L;1C@$RLl}XGv*>C&G>d`q}*6=HWNoD2~7H}4JrGlnUlPw80X6S|~hEnaS zaeJFeckc^V&ZUV$5?Z+?W{xEaT$uc@W)vu2G2o${r?ekBLO2t*%?i(f218}P7S z$k#VyaOh4HQHGRDLM@G@vB>P&Kmj@>^)^!*7}XQ@%Myr(cfQ zn#miS_&oDshS|p`YX4*v*yH19(l*fE&~2>9sFD^bK&>-*Qs0(C4*;09KI)%;2)pj9 zaq#c&C=w~u(p(2oK{w{vS>7{~N!9{P#K|$7@3<3AI--4N@ULP_{Y?%atQ$ z+V#2@l+cq8P-|cKU{=7MG=@W`AX%o$awP%vveoI_#W|2o`;E(&gD z2Z)b=;CH17<@U9_5f9@OY&YmTE~cbsodOL%R$bHDV%Z}Pj`Q3lgBt7ID@n{&Fphij zp=O$Xlf$iK3Z+Py>B~?0CNy(h!qd|ivO^SJwsi0|(;s-LgHa6InX9sgZSbCq$%0Z! z{*ZB@_&(6IY~y*;zC3p(pM~zMvno=K+JmKYLY^glZF`Q93zn6$F8VxwXp`fwLYZHO zO2lHuFlJ4V%g8;psKQ1aD;^Rnt9ixCsCY@lg5yV4(iMuMGi{ z#J^;TBu#tV^oR{rQxZ(lJgWdQ#))IKeWnzMD4@g*PW|LshqB!|yu>FCJkB-XQSTcP zQ{kn6DEr@>W+Dzgr{2G3?PdO_ySkJ02O0klWQXw(w8*ng2&D0PIHuRrsGw@)H9=Bv zn~SsZ%b6vAXz1PUjzB1a8;=Q^W(L`jdee}_S^R|AcS+rqEBuGf_p+AaR7MRTjkD^4 zjFb_g>kKdbY=NAM7?`|XVXg98OO9euNn-r!8 zSA0dCrsHS8xrm;K92Ch8w%dV(qu5F?@Azo31Y}y-;~sA#kNKGib9rS`pE>_dbyd1O zTy1Xp!1MWi=%omT!NjZ+9=qxdU_QpCsidN!h^X?d`%~Ff@0?H2?Vj*Dh9la=Yb))1 z->~vx#!rSyp{(|DmDEy&3haQj_fm9aNepkNUxm`KU&~^mwLI)0?sf{r2d}<}N1kWl zKDUDXvI>rxYs%NZE!rb9vnLi$)NO6gcPn+C6HpajZ+XM6E|~Jmcmi??`W((lOlupi z71lsVeS5ojgC61-O)o6^`bW6CR2*bt%S1c zIA3|#(8RJArQBO`3s)q3tRn`H9*|{-SH5Zkp+dL*jf~20w%CVvYsVC>`;&g_bYeHI zi^wm$8Hax{{au{r6=qN|v^QSiw6%4y?Z(b^Z{Dcau$5(b_K_t<#-1VbBPo?7f#62# z82v`o`rvI!4l1k&n5|%_x-v7hCxwf+^6d$Ni;`-@wJ9rf`8UPCzDT2SUEknDsGIPC z<26o178<)F+=3a+0-drGPVk2h$I63*5OEw0BzqQqLuv`C9Y~1@Q&WWdd z(r=z)Z&#bopf7lxHugK+tY~ngv+7#p{_9!)>uc?m;0UEh`7B}rlWz|tAMrICr_2`G z4J_D7;CAijUk{Rwf#$<|)0TSpNPh!TuBYH@RdtE~si9jRnx%y*UMQSu_o9!qCs47^ z5HbWAJ)%14qL+OOw_%d;@P!X5oT1O_P9-jUh%rt%hO69ev61tA>80cVOOf~5-m$RP z9y_`%)wk4z#p9u&=v}Gh>4PRvUxxthaeBfdY9NJ&N(820ZZ8Aik4_P$DU4%I6!I7H zOYmggd2LYx9ptD~9ja{k5Nc(I6a^)LK(nV3N|d1<`vU%gmY4%*(5MlBbqFBN2}gTd zyzHUgpZf(R}W-u?bwdBKn89{-eRQY=UBjO zUEwg5?XvH-!{QNjRCV z5F}90Sq#>u`{+ssXt%~eXW@wk#;E;IaH*e%PJ41EC|hKPzi1LjPWa(wI6YDbAv=t` zvQkT1TvFVVvLfhjcI%PY7ZcXmvQPR7%rtFla7Cc}3P*OMceUdIYD*kdUxo$!=R;YR z5cJ+ONJIKxu^+mae-3{!cS_d5*m9`|$=fj0_}q42u|zQD0PXZ>x17pN+D8EWf+tua zgC&)n5Y-Hz;a+AqXyn45;8O4FO1IOQdjojn*Bga97 z0+yj8^U7u9g*f};d!xpO0QH16K(*Xn|W z5OxIEWHDVcFcR|$7N{@#agpv%cnOW~SJt3HhKi=VTxx%nzdv2#SXi2F>2-DIZ15R_ z*LV0`Ll2_p$bOUr^7T21({Vc?xptYJY?KlJw7IO0j1M_ zE&SkkCCfOh1k@}hb<=J%4zq8ce?$a@qLf<%-0Sv$-A2X% zM+|`xpKfAC%P=*2ew#k121qdXbOhOZcAEJn+PSPUd7eQ$NcfaQ$I0k}bK$4zl=t?w zHkR^NYcCO+17|3r?Y?0SCwnuazr7ztkcyNoPBM?ofoX{2vb$iUNp=-Vi=;(B2|`~o zRdY4{?6XWc7o*b{nc@?EveTnuArW5cK_C@IonNcH+*hKB5Vm2p<8U@B4tvj_C;pa! z)=4jM_x2}IXSbw1k7Y!-3vu1zGUt)o`3U6~HS?vT*s50YR8{}h?g7{taigDKFz9`V zUX?orPoMr#_AZ4J506xqw9`9Jr|~q5cJcaXvkltmJFfNQt(<(=c(>MoJE-e2_PT{| zuO3l5>*zG3y9HxE8A9~!C#r1;GOCnFWey_rSE2=)uQacN$2;0PlU@GsyCj!?;bG=0 zet}HyLpx`pyHb8%7GSRly#kLkECUFpzrJ_3=42+2H^Z z+1Dh_dP62n{qjZWAN&EEOzIY+BoNNFxf9AM?=q>Mc8A|W0gVwoQN7NTBk()<#QsW2 zn3%6Iy8At1DDXH(-Mi>2uKC2p2u|0Z?M8(g&t*hc0~H5Eb}9tNDvc_!kA46I(;HN4 zIsRbH8<@NqOn@>U`6}U{$*ih_g=Pgc7CUmeP5KbuPgVNE0xUM zkGSoZ@8wGJc2Bz&q0|TyZZ~NowI2Q^^z(}Cs5e1N4#I*PYs_#g^}wH=`Y^aru#pka zQC`tL{vEoIuBrx85&?y8>$6!K-WgIcyUMV4g(kyq4YKvMhD*|SoxWJd)lhK|qGk7( z95oO^Mgwm#A4*EAhtpF9Y|%wP5wn)0v0bg>CW)wmDbrSUCMi;PHJ)?nrC8K*gF(V3 zN*Z+e6@+-q611xJ4xsO9uOn0epW6#_OI+Z7!J=1U&yzz>s{}bE^Mh zc552)a(dKxx=Nka@7t8$`kM=!LFxiD2TeXu@=d7?F2H5-6hJOcL#XN)1>$=`InJrc z*X))Q#2zyCVP&)L4%VhTz*7ELaP=usM#^I#tdo@z1} zurV^od734^qrM{sY5e&_)>x}xvr4GDbCm+6B%tQIkylU?PJhwp6dD+z3WI+o-&?&U z#uBpS>T-Q7TGhpRbKO_;yCziYDDM~K7+DrDBie*eIZRgjCr0eyuSlwmwI*?p(s6OA zaGEqbk!R7?i+8sDj^tjS%#sIWC45$B=@y+=P)n0CSCzel zHtd5YTi9Ap9&>oUG#8AHl?nO9D@_BB-blc^QqMau%DYYT50w2WkzEO6+cNfLc@!-Kg@r zUh@8F1ReAG#RuOtZ`Ir!o?SqWB2M7d>#=Vym^P(+nOoyEv1e5g;Bs_G8=ViLVJf<~ zZAIe=Y(4@B02fmt{HrPi>?> z-!oVJs+Aq0@)0u|nrb2O9aV*h4d`nFB_+pOd66uO*Y3!Y-0`FqA4nsbVT4%TutzK&3b&{|It)KocM^MIZ5cYcHs>&14`Fk_O34Mg-^=kmHQ%g$T9IW-*jag- zFmRP`Q8Uq(VH-A!3QpLc;A+I`=dIgeCp+)}uGmdIM!Nn46H(3a6>$eYxfF=drbkc6Uh;~ z{RnE=bWfJQe^3VB599@+&XENON{P&6wGJf}zPCy_BXRsbQEI%rJ~?}I=NAS^4WRik z98@bzv;)MLi7e7rm0xB&VR-tHB~D|!5E9Kr&p$jD+~o8QDN5ADltp9eUzB_-EUCVO z`0|doj(P#o7#zKMN_a*F@y*~$H`8;#E=OP%oNaq1ym56+hsp=rwTbIhWye88K_>q% z6Jp3bY6Emz(;Y=(0y$Rt(BOW|aO3okn!#d(c9g&mi9vO}=sV8N)ZX z@qSExMWsi|hSUuf749W}YX9{1J*CHhJMbB3?T6$M?qTf#H_3mf%g8ojo1?N;TkHRj z6k(DT@BMufl#{Q|MtC-x?xBMavM&$DB1rE-1vhNo z;>MSTCkCZ@I7c@tGOst{b8EC&X?S&zok(!|G&i9BN04O6jxE+{evbGz&S?Sj4IfU0 z^JV2l$MzcfojC~?-QHg9=8^w>DKOakcKj+iBI*sA&dtex>O42XSF*Hf1CwoWj9S>D z(UWrDHc4djb>ng8+qg7dQ7w|Ze)#1y_HR(WW}L8*V}`m%`$2h`kJZPq$W&=F)3N5h z4)Jhyfryif*1~USxP-6(#0yf=h+!00^{aymj=e-rEh*+?hSrI6a{o^%`6oT^N6|ex zv>)XM_T@VQ-40M^H2l4xIP}0S{(6e=Czhjk0=WV#Nq^CtKjQ}fva?xhDc7=twPK1} zTE2MYgYT8S+>R+<$qsBDxdtpH<_ziUxBt;nr~QVH50ypH5x+bjSO-YOqB3-28+}=` zK0TW>u`=2_ zVX0OUCb_R5x$$KYvn_azu`gOhqiqzolK)EMjMz#!*@XO!zMJ zl+@c32}78t#pihzVmo#wgf_4?<|DsdqS28K(IZDMfRnlgRQi@{eLB_-uC_v6@3i=^0yz2}8ZKJ~Fo zJmmNfH(n-oF2s;KaAO5*)|uArq?An7Bm!&HEz>CvvgA`tixbZ>nza;&nbXyLx#Qrt zZ(m+weEyD+vA94q~)-aLPsyTya~WNExq0=y_sRd!&iOTzTjzTJh_-XUdwM zH#)sGnUDP~^F}l{3dsgIr!9uA&UNwb#^x|E)gE3($+V4Q`OM0$*Z6>D#De$v96bwG zQdE!g&j;d3E^PV^Vpk>H#*tMg{IK|?{r&+e#Ot&M{xVT(TrXHNtev&(b^D9Muoqcz zzuflnl_r%~O!Plxsnn0f?NjGmF1@jKkn z#)>qRe@IW|+25hQI}IT-Ldn+EPIKiO>e&cqd_i#FX7z36DBeKaWPY@6UyPAllyzSy zO~aD%;1(QDkWi<-Gr{7YPm`m7MyNKpx6}(#WKIwl2n@+!xP-Zk`pLo>K^=Cz*}454 z1y{%^P$+oDNCnRW*yLlVV5Q9Ci}78Q5!+nqrVh|MXSQ-S#3w zO^V>NpnJM(gzy&xILHMWu+;0|DmHgPN)U#js$x>H)=peRY$K!?8o5XDd{R5$eoLYB z?uo&s&Y14Ak@XyRVs2e9&(}V~#~|nmPeT2N+cdToa`V2_#bN&vv8fZ>nIg=ZV;E|u zow(-d7~D6F-vUJi)GikgWWKxxD)IKo1kZJC!lSwrj=^fPT)Rr~GN0Qe<&OkqCQ8CT z&8K52jAC2k40@f}6L>zgAeIfsq;Lw#$CH zrjz&GILl9|RDjrxUz#g#nhx=aibBmku~USN_njc!yiZd494CJG#qzhu(q^~~-`-*z zwz#E*#FOpxip-l+=i;~~`1-QL3pWKLedfD#FSw6v=CU@-2(iD=7Z94WQq0ris#&(h z`ObM`&FgH<5gq4Z+ho!By!{YLHu9QRwimSi=yyERiobTmfl+oeT^LuJ#>9LK&0K+} zZZemFZP_F_Dxu-|j;NQ$?`v7yc4D3q?3LuGM}5jSkYh$SubbMznVt`1yuX()H3ZBV zq!Fj!52}V=IPF_fGL^*(0_~a1|5x=xrQNdw}Wu%2(Qd=E0MX z3JZRfd_qz}IgHYc9ZZ@{V#^C+v(b*+3T)80 zEy0*)k2QYxNHa6kU9OeGq+#t*hw>;+)UY<3A{bQbf)Qp{P>j%=8iV+Km|amht!wZ! ztuxlv(-xAAE)`11vBMV2HOSxS(8LJB)`!H-I0&4ecDux|oexhWO8ru1B^X#J;^&K& zhqK@3JT8_oYo$4EB^YD;6*GW&58;;W_J_~_OC5FhN7;Z-ZCQT-m!#(gzRJ-MXlKy9drDAV*O2z(pQDAK3?e|=7+II zMzXr3scOl^RS&HKZfueoLamp|j_kFdA;i^WMciwj*7+Iv;7rGz=mn4ngIwX?PD*o zN5Qz@x8IEL*pQ1i@=kJ#*}qqtdE|8bYVg&_W38MgROR+h>P&OHpQJ9ne~sF{{gYZ6 z$S9d|`FgzTV3(_?SN^vGA2WGu>}tX+s>IBZxHJcfS9%I9^Y%?^BhZ%|JIZoivo*55 zg`ls{s_GZ}mD)Z{Q_VEH0cKk`5KjAf_R9j5K@w|LY=y0oW+d2AA zYPg0eh3fQyX&a8?p+%ZyyXrb5XQHbG!3d3?zKb?y^kb_5mMJcw~5mV*^T9GA2T1lh2W_ zX4QFmfA{WfkgaNbY81C!1+{%W;rpto1+~}O9wDis5v&`yB9vGKiBrig&7s&ueu!gnVEHas9@H8*&`tb=d zN*Bz?<3#ton)a8AI!O!JRt{zP_Dndm`s}0i_7?GGn&xpne+|z&3bR2l_Cxdy>G5{F zZp6jHLL(zO=^yg^0j>Od?1p0f8MgPhH9bka-S657CQFJY;oACH5*5aV0{CE7B>W4o&LQBTFt7gE>14ZND3_c>&GU{F|^^Sd~S zzrZ8rpw_%H2~1O^k|l}uIH@o`=^{KT__C085R+1)^{to3coskWMdN;V##3IejeV(E zqDo-x4{Aj*)U4Gk+iAI$e&Fc)$sX8~W1WH4HhNeZ%$?w1Cg|SSnKX!iFx&l z=fLze(uLu0NKSxisyiB^n`BvxD+kq#Lz(IK@B^Mdy(7a-Jv-KYv2UJx!0jU+C)AsS zN?p$`=oZQT-V59FiALN9M>Hsb5?6u_@nG0TvlDNdn2VliUA%JI?I&dVPVC!_w{4hC z)1&x(ec~vn7{|7(Sr)*G8!Y&*I{E%2f2eg~Zz-#H22^OQ-uy-f8#efp@Sqf76t|bf zxaT|fQMuF*D+x)+;!9omQxhdNnac3lHr)4`e0IaiUeG7oQ!s>O<1*glqzg`brFcfQ zts}fGM)ATkHCruGY*R#w27@RqUoqio={By9*B%Q*IkLy2r)-o5aqf0~NBi|E5)qAY zzZ+~{PNWKamp%m;u`>H?+sq-buq=Ip1#bO?cy;^nd1NrEp&FqIVuIu>>Tykg-xUFM zZ!cmPHTV{cOb6^;r138(KE^AI>K_k3pa9u2tUgu9HbovEwf=rKijMfaMQ>oQ=9$Ea z-jYz;r4TKh`Gv%5oiqsb?uRaYHCl}C2GBws75Ivb2i;7H553YS7M$LSNn+-`hZ^%pu|Mz>?tAvfO7t* zXwFE0i0=GjSA8(y1lzJf6}EsN%ngMHQDDN}(*Na;p4oKAvOk{Cw(&;!(&2BZ3%=IA zT&b8OT@?G_?o2>m#=y7oOzOTZj6MN2)7XL1{z_KX{m?t zNkJ6T(#o>hve5l@gOn+ER&~KwT)dnwq<_r#E6^G548u*3-O!RxAaG`w!(&4ewWm*a zPG9A+6;Ftg;#}>G?GPq2c(*!bwiRP+>CVGSScN> znOFkBCV;Fkm&}Y}_R4IMT9;Hz+cVZqRoQDapi4Iddfr_~?Fh zgY5J$)uz5acIbgk%~FkKR17krJF9k=z7P{$D}`*C;v(22e@7_2++{K>>UwpT#MZS= zBgBdtJ%Jj%n0R=xBiN$2figXhv`lg?4s*XY?g6r_?e@?$CCeG73tqHF4jfHmuPWVp z+RW#!UXH>=G#d_2YLeGtF`tqyny2S?hyCrP9?Xvk{=GQ5rF@aBMv$rpC*Up)bp}@S zlKS}htIyvr3ok~hZf5P!(>;9)F9tLZR533b+)|Jwfj)SCdojw+d`#h_nXLw?U^OfE z2j{cpyR`V2s_9_JIe<2J2D2rSTq-fMjYS$yhij!e3gxZ(3Z@s8`#WoH56OU1te3U3~4WoE2+9r4{&CAUY;FiJF1PCJ@fpW-%((Qh->5H$EPaQ7f~&M32^T zm+wd}(QX(Qy|MZEY!wx#j{iF2n-sei)?;AbmvV|$_>I`AfbO*@al`1tDbf5a;j2|; z4-}1;hBx#``jR2#s54aV$tAs4P1&pGAV7zMo6`ih@^jfSI$}uY5@aR-bY1Zo}DjWtcRsaQDO-xdk4E)ej^Qd^$3l-!zB*0qp2hiNA zCGxHIC57(qTjkHISPl@vBdg#^jYAgK@CEf_tBI(D`PSB=6FZhKzbrT#ESN;9*SsFw z4+ibuXPD3wVfFUrpnT^UL$dXe2z9z z4G#kg^|hq?Eoyo@Q2^WCgWZJy(@o<51mQfV8L{@zNDC2S!YrI=&2-|CiCtoHMrr-& zTW%6;MY%uD6#7fEJamNtpMyfc{}4xld;%}2Td1pG(k?1@8YM!WF_EgasBE8 z65kgztba;Nt6Z+4V><5N$Si#a@De3mf6{)Stil!AYJN3a#Nzju#Ky8Gq;v_mgit60 z*)M(Bf_`AGsJOD9b@9Hhm$lHN8`-)q)C3mvTC@(;sXQwC;HqEAP$I3vA6d=~_*lTc zC84`{ntLTh5MP^`IcE0QcID-ow_xkSkgZ_rxhDScVBVc10$lb_{$DEvT#wT|5V0J< z$q}ZwRDfxX*_W5TsH^qEZRnCp%Gjj+Aw-7!fY?Q#$L-j5&voq9Dn9&Zw(c+DaY&L| z>M;E6A!YFyBY~;>L!Qh53K?>#sA&?0s)mVFg3o^0Izh}b!pCI^zMfn@&>w5Z$5`3~ zh8Etd)1-@(KDLjMIj5F;kSoz$-tKylU3K00wUIf8N)i}Wf*0`}1L6bILDNOZ(yv~~ zaa34o$LX-PZ=@pea=pOqcx=K&{u98$`7YMFQ(~bu8jgY3=B@WaVh*%0CU?s-3-{We zw~-z+CW-5P&t-}3a#Oy=6z zB7<*p7@JqK^;_JhR+jtR4JhaWR`p#Jjpl(buOK5B+akNUOV~?qSfE6TmOXj z18kAp#yN&dIbBq!>;9MI)}SK;vkk!E4_o*7fnC zd7^TApqF7N0QFa8xq;S+X3kL*Nf@-Yvk~_JK>0Fi*bf{x zogc;vO+ND7v;Diu>cOb#>u4PO1F*Qh(+>u8cuQ^yVOjE!|f8l4+;dMdmh& zwwKu0=nt9or?b5h-K}cyP*b>v@xbXcwHsaHT&s;{_JSMsOPa8=#*t`G+`jA0r$jqp zU3sm#-A>b@B`QVnQG;%vR;W^2URem%4zPhy!FB%R!@bvs`_Vt7-XU9DahTA=O#c4$ zg4()^-Syi>z5&3Z7(@wEFa|B0BCTQ1okBb;0--7#R&Dv+EBB#cY1rDAnk*vXkc&X1 z4LySH3&n{bl}0pW^6kVi3eRZ(58A4IDp7`{L6*W}-fked$g21=igB?#)iF<+3n!|J z+L5+`LCz=FpE^E1Mngk?ye0_p7E*+6F^GY^vk-8gH+C17U{Cnr6XW2h@!{=shjZF? z{*PU$EBdTDTMm)y<1+JUk4}eVh}_L$7p(YHR#i3?+zu~IitZrY^QzVOte7C-Y%mYm z)$k2H?5m9jY<`6ILO5!3|Mp4g7|&kdX8vN3CJy zV4*xUlb34m20rQ=TWC#7sqBvL7X!e-GomGR{|k`VI>2JzKx~Y1>FV8yMvE8g`nuhZ7_*Y4TA- z5g0k@4{YPdEA)~4@KTrGD9O_+zM=LCAuGsHNg;R4u23bb_4|Hoi((#^W&>v%&0Hbo z-CDpk&jK-sVf}TNj_e$S&UhnC=z#Xf|p4oRI1>64N z(vhzXo{I1oL|OfzO{_P=EmkPY>o9|#YQH;l?_y~1-Rld4v}OxPF##5&bn_@E9+}_s zApXKHc{Pz~F)hw#AN^0!hfWL#!|2G|f*7 zcix*h4%+^@^t#OKR{GL09`NWn7d|ms^%EAK7}QgoUi3Tatfd}e31u!WgxHoxv>)8N z?$fSIK4Dp~aFA_05XZO(Xtn3QDHOl=bu3qA_3=2fYd2@JeYeZU`9s6* z{0KWQyKDP>dPUks@hapS-y{#_-DHduOwx;aF(x zbo9=|rI0}J++?j7P2aH^<$eh=8?iK>%uN`~3cJx`Qwpu9DV==l@~Y7hZq0cnxcJyO zKQ(*}Uaa0A6_p~@dRZbu~>%!x)>dh5l_j8pxE&@vsO4<)IFP)sW z>EB+0+N1uD_P#r+$!vW$G(i-xfYJmMloAo?(m@9ikY1%rhe%O+7f{p)qEzWpq$VIG z^j;M~kY1$sP82W#GIwXrQK@rg&i&n4cdeg)uz;21%l_WIzrEk`Jns`w7#=8jP-S*N2M=yG59ZOv^bS7A=&FhlfEGEu zjyKik=d2Dn1+tE^3ck|?=seIKB6I!nh5|;6u?&4A=Hjxweu84|c`eTu!;VW-oKkp` z3I{LacZu-&ONp8nEd&_)<{Uo9dZ+ScRr~;Ff7zE=PxgZ0P3jF!G^ouVs~wIdyh$C2 z1+Tlk?yHZYJm+>aO_b9~L5{#9XtpTXtK7i)!C*HntrJR*7WTN{O@(#fjboE<3eT~P z@E=R^Fnr!#O!{2p;AY!eSfwWfwt2F3`H>Zh`fI2wG*ngbME3l%CO_^tF=dKo{HQ2> z^`?Qd=#zybO(wH7B8;U$3hma~C2i7mb1|M6^Xx0&m z0Ehd!@0{0Gb@i5J%CZm^G4vf)E2S3Wi|mVu=E)IP!vZDw86&>2Z3jH5PY`&-ZZ?*G zGA%z|zQ6}ItnSqD<}U#s!qLG>RpRWE0TUkj>Qh~Fh3GahwBAF#RS!(fhko;}tZ$KW z5n~$}{uL+(QTyPbik>(0%=GukzrGV=q=8RVciD|M23Yeoq>eJLvrK)FwTitKkSuDZ z*OOioOJIM#eeTPQ2U$_jNl;;I2^EsCAte6h8D4@O1lYpzx6s22*stnaZBy$8~mWpkd9CGLh?BirNZTBIjxataun}unT)!6bv7RB z2a5~YQgkX(AL#zd+Rb0B@8dHVv99kiC`#E5;chyN(>K>exA9!>n4+?D$?%dO^=LLi zKeyy-Y zh)%yZG;Tb1K$;UucEgInmHBeBc(a=gtkrWkLPY4Rw^_%>M<{tUg2OvvR_f4w)uIxNAz~QcVwt3&znFvoQ)`| zVyeo|m6*E}h56afOB@+5DlZDAQ}~o)x&o>MfC0K%yw2lBgU)|i;z{G;k!*je7oXPP zjUt=j9bB$6&@w4TdS<4SNk*@)^iqt0cV%HugG-~xzO)YwyKsvX!c!l}^sJ|9S)MF^ z6s#!WZ2Iy45AGGHsP5H}2t2r_WvvG>TDq;v?<@`0nnrSqn?vV_NS>lDN?8$#N|34k zAOQV~3?y#}6CRtkwD6TOx~z)F7<5(NRkU*P=_Ut8JcXbwaoyty*Fr(txZ!x7ORi}w z8+zla&xY8L`YcnmD14IygG~4xVu8_Iw9E2ZeRA_s{>eF40n_9JT$NQJ8V`oq7`l!P zKBwC}ktTUj5Qo?G_(sYl{3Dj0RRSecUwo~{+cM|hD`{w%*W0*q#>|N0+eopBYX z%7Y@e7M)Dcopajk3zLgi^R4ASiM}M2*2LHjpPGOE688AOW3=$8>+P4t-6=$kf|nb8 zf=*dGap`HxUM;K9 zQ~36zdQFMmZ{gzhv|b^l-Rgs-DXF#kENXfs0bgU(4832ek3Poej9UAYANQaIrO_(o zmmjtIk~d1?zjoHRe9c-AkG&!eqO8m*M;tFTO2U*(YQTnGU-GFlk+QcY>8rM7I`1lG zY4p+a(ThA^(M3Ex{zt=(r7Z5hLnhopnHY1veJuNorhk-To2+)1wdE7eIwqi6t_K{)`eS#I@;RmZr4;;Bw!akikrc&Ad zbn5GI_!p3H1`f&7yw(@5mU2rxkIUmf`I_jjjcl#}u?a8YEt3zANnbzPxn~{(Dia0c z_tWxy*28_CXeGR3&Xj#PlwUi&IqALPwYlOq4T}Ht8Sr zv~ey>P8NiH`>J)}nseQirxogM0`1C{+Q)iBu@Vo8$+nYTCIS zJ@YZlXw!#6C*tKt*va*3lcraz*)Jqh3Wtb|zgShp2fHPUh_FYe$XQItYQSM9zNQau zoIR5KefCbJ8?EJcNH;z!zge%D#H-k3bW=r_*UIY83~-d2Z)Ceg+I?l42g+unZ}C1x zWz{owMRmP3p{z+;&s`1}Y0hXUa3IsmO-GdDgP76jVe8MGQt6&l#f%vaa|QqsRrRih zC27GUQ$ap`(vzZ$ZMxIOe9hC}J{_i|(a9VipiuDJQ*LTi z)!*(BC_o@K1kR=8cY?IISaZ(^Gm(9h2j|a&L3HHi!%|0pf>9U6rv5>MNm)MS3RJ|5 zZ9xqJ`Yt7HHD{sGGiS=P8TEys-E-J+!vrkUMexSTkY*6p19?-=I_ovsmB9^4fZ0bk ze41efAE{m!dAPBzcUM?)=j)%5R~5=TGBbFDl_q4~y-PMXi7@4qV#s>Om2+Gp=q=+| zhXAWFzi`j13p|$vt5{qZiUUAt_{BMQVa%9liM#<9w=3p#;l{$uZfcf_@i{5d@wF@zPF02)J@wl zrlMMxn2>We?_`Mlh=i!B?bM@k7-{cudR$DMZNQ@V?ZNj9YF(?P-{OOkpY)-#vqj$% zf6a!s&8m8af15nk(L|l67u2*KX0)d(E5Tri z??2ail6joPjBz>@*MzMl-mo2O5_}3iop%?Z1bGy=O#ySo2R!fa13wXmQYPhv zUt}9Id*$b=uB00BkRB8)R8*9>MZ7>EFc#Cq?!^OSwS5b^R;m1Sugcr-_17O06}a&A z@YM{}`~^WN2>k0BoOM!3DW9vb$+xmK!PA(4dS(up`oSWG9c_}ItYx;=neXm-%QXK@ zenDZVhCz3+x`80MHai|f|4wUR@6-i1woD66o%cDWCZBHh8a6(|^NI;+ekNXt`1&{Q-w3%pZVeN{Dg`RZ}w^GIbYhCV^xOd;J%=HE5W*&s3xr@5+1 z3-t|vfXPX{)Csy8j%ix@Qms~YY$>TAFG43Qe5|fB?^Ez+oy6PR&vV=-n1TjMPQqWP z1nZ2DJ`*xAs zTQ-9N=M!^1;eiq*c!6x~z=g@0Vc_ksY4lrTyBHCQDN5}2_QWMDVY|IFH8$qAJa&Zg zLyHucfC^fM9MBG7k>qKrfp#sks++ZvA8~;(efm-H17&deKE2g@zxDRk=EN!+AMljG zEt8ASOV+)k<`;39!&!~0q!2tm9_Cz~B4^z0V3N_&WVz_Pa-R99+ovs`D-q!xxnF-g zKI`-oTuG#}Fqw*+mE0#s0UL~kUBX*wR%o^wpv+^Nih$NGNF-@>Z~bF-k?I63;l^$z z3%{iUvL@PnvgU$)+GnH~7%vHnlM6Mh;)0K);BF~3;=-XXvzGEoQ_UR(nxZ4$nwkf2 ziXA!Nq7)qX@rVbUh<@n9jqUGe5n~*(=Y|BUi+c`Ry2`Y%flM7Ayme7T>oq;EK$oaA zr@TJ+mKWO^E07DL5MP2`q0%VNJsVaz94KqPhySbc8QOhVbN2xE+U2B`q;$NVNXXk- z@+2-=+B{(NdseZ6uR_+gyS!U;hz=~w&@fv>Pftmx!;8<1kRj7owqr+aEL4KJ!Od-J ziiG!j`(E(_Vck46;z`GKh8bv&n;|;CW`JwSBxI=nI(>c{9;A}&B*`*m=BfDXXo|PV z=hCQdgIQ@8|F>Wn&L5rZW2n0pOE{2Pu!uXju4;!1ApvhXPm{eO>v%yMjg}elMWK~- zH~TwP6{`TW=G20pLncQ&Ji>022q-Y~E|AZN9@*q{yMocPp{puNIG1YKY|6K2X|&R4 z8YkQ%onPu~PmU7E_L=a>xfpWuigt^G>5OA_W}j%q=Gjjm%M2hk%SB zz9e}QB|^u{%v_|NRM&08_GOuF`$JOBQpmBJhSmuz^j)7Pb@+UROh=jt2HeZ5B1+$f zaMX?B`+1>T1Oh@H=HNo7mZD^o1XR^GnmryKYwyi2k5&FMq|`O;2@=Sbv5$&?_}WSH z)iU}Acfuj-=PK8-@#r?MW+s)eubXTzbXG}bxMzyJ7@`w7!F_Yp$uY_`gnXHdtAs}$ zWvwGRbh^AZ*y8s5jJuUUTl#|*Kw%a_U%uAjCY3ypvwVHQ@Utixlg-*Oot8;_^;eX2 znzbJ%QyEvulvCrQ#mCfeT0!cYP}*r)e5~ta^t5b-wH7+rXM;Nt^H4jhjd$e~A4iQR zlfDHLV@S_fm%6}nxkWv8r`Xjp49jp6y4ON^HYmwMhJw=9b2hO|+sM_I=d&nCDp(Dk z(0$Cdacp?qokLD62Hn*7VudK~n0(enXk%vN@Nh}ybn2TW9@A`5+3^T!rx@3V8VPK{A#X}E&_DqP29rwj-W3 zi@a5?gL9U&Hv+P5o}emd|4yIy`G@i+6zv3;;0`-YW zG%3-Ae~nUK?4Ox&4Q8$j98W?#6bwHdU6jSR$=%ERvSn*!lLcLTZT9Sn644smm<(s0 zmIKo_0>HOi(o0r}N42KC?&-r19auZu_2h$uv9zB)lKfWQz%Xc)77w<9d*6Tfg!nQC zoeVYey0}O1R}qwVap<0Byc-FtC4r43m3}Kmq$NC1#Zh7JrNwC zqKR#@_oIUqw7racL#@k$Y?eKJDo*1K0)dFjc_!(Jbhadq)>MqrHp=jg&g13zX0cc! zfO?;enS!bbICK%RspF z&}1rQCZ!{%prE~h)P{Mkn#xoiTLH4J@7B&cqodBX%4S!k4@k*02C3h{6Hd*Q5$Znn z^xlIv4&&h~Xz;aQ&D~&Ucs?pL#T;N!ws+MeuyV52D_g2VS!S5m9GutS9K#i5(6Cbq zR#ww@aja#BQ+3tKx~@CkRFx!7!%fjE;^-}@gR`2qVF@TN`>@4*gKhUCGptu@={PKx zy;cS%_k%YyG*I*7JFayd%A8gAIMb0~@A}cX>%z^~5Smzv`uJ=WgT#qYgrftt@$LkTLx@*>DRc_0t?z;x86@knpz>GME!Yp-kAuWS-+8PnmC=}4XmB(M1h@0MGu(k zlC*mta=&!x@G)`yLGcK*3o{~B(T_YH!P|%Jm$q&9JTU3Ivc7m2rq(+VB^J}+b5V@p z6Hkwu5+)AmrqWfOZy%y!llGGJ!Fs~!^hPs8G(}-5DrI3FxNtkn>=IU04)0y8iZ)(x zCxcRwhlB+4-X&UG$z+SqNtfn&;uq4=mRDC-j?}?CR4eRQyfdktWl{mT>z+;vXB{OA zdFBmgPWod%|M%WbnCql9YW=u`ZAezW!r>N4Og!0f&@Pl_g@I@E;!m42L{rq}lNa>u zIu{6k|MULY+m7m=ofdx_$wh2Tb+l|P0P1oJ=Gf~n5NlExO5@IZDZ>GNCrC3c$(0}( zq$2%KiV?ZpO5qiqOf0kB^dr&w;L+|$duu%g`fPN)v$F{Ve80ge%rYMMBl05GyT8WT zPVswM1O(WE#0vRk&{?PTgXc1Zgn^F72T^Kkt_e)p3Wy$sdJI54o*Y&?6*meKp4eQK zku*%(_zk^T{2b{Nrc_4KF6+qstJ%9ZC$Is{{Fc`Vr?P% zd*@yr$d4)iPfOz0>pvQj{uP^%{^!P(f8{d2-m}N z-gIliI)4VxqWTfu46H}Ua7m_S^Dqc!M%k{%<+WEIC2tQow9KDLiSP5gU0poIDP6aN z`<*52+WdHKZgc4Uz*E97s;o#@$aK3!z3|R{xWpfq2E5!y+)etfw%z0EzohyW;$iZ7 z##JkIZc-*vo#P#41Hk6P!*zSDh?YI!dWTlZA4GgvJ(=6^iCm39gRX?DyX!?~XYt5s zy_&G3-yt^(VBv4@Y-yGb5E!&8Dk(}^%~^F}eba3o0%58f6r-H!rq-!<{R1(}gV|%A1>&?efkFVdU)702y zTiR3|7I;PGM0=1%9oM8~xt)uKH=G%Xbr^rJq{-)LPhrlDc#>gGDWk{3#Z8k57*8o^ zF`YixgWZUH@U?O;PsZ` z=ic5*nApv%RiLg^`Rw5+p8qET*haGv)U_$;TMO&Nkv1frbD~#>rcS=#<&d9~KPK&GLgUy3Zv9%%u?HkS}3OA=K zr3l(jzOBDvtIIiM=x}W&(FddUEdY+1=aVV?a64l_P_V@Lxwj2S2#!ec^Y}A2@x5Q3 z;1==g0QHw z1l&8tbeff2X0okzA^7rmCDM{q4$^E_sm_S=HKICo-YPjK`l6+F{RLCjiXm@SV^{M6 zh7X%8ZtR_#Ct-u#nr+ZGsv6|_9!t%Jx`tYsi;wI*kLyN$Ga1e>r6*~$t)L)(048Jiaoii~pIpl}y`VIP^D_5(W)S`<@VnJxugteRg zDJe?y3i@Q$aB*|~R6d&}FVV+jnqxjU9r?I)-hbgcqAPXqg1nNfAw_d^-nS3a*brpf zii4=F0r(vhzZH71COB73GIemlyJiDzV`r5ls3+h$iBeX?PGG^e;eoPvq) zG?WS*saNb^s5YZ7K+*raD3u_TgWx^S`ez7Ieb(S*jHS$XbLkGb7DY5L!e6 z$)FPXp=Jx7Jjx{a%dv#pJz9P|9m=)5!|~G8DNx z8fQZ?l`!f{$+{RMqU?D*ney=*E-r#P9O2E7aa4Ys(-RHQccO1uD>N?>-%9x@Q6(as zr2s`}!ef=dvwLIHSP|a7iz%qqtztLIZMAI>zwf(&y^Hhjp-u}V9oAaiYa^R{%sAG` zoxnXP*!Hr&2t?-Fr{%A69CjX5zyAOG2R!NT`(PdZ{-u7I|3BM|bnn#gFVp>J)BQI# zBK^Nijr@ut{$?D!PujuF0(mw)I_*0C8u8kp`b~U{b=-zv3#$3ZtoIky;v=Sy&fp() zLRhFPSg@x6y_;QvE6i9$BJ(x5bf8E?Vl_LbcDLZTjNd$+bhvcG+_CqHKx!nj%7b_* z04^6h6n(=&&GqO4@wI~r@<4`2`C3|(N|++b6r0Ku-(FI}N@6e!S)aoA&$-=6^XKeQ zgpbQuoss%OdkA)#Pp<3YTyA6lO0#B+@kO1ONQfUSnNL3LbZ()~P7jZmIWw;0#E`u2 zT6wiFtVW=-fNdpR!I%2({ivX39)F9Oh+-;r5$E_=dQ}G%eue9V?aI(w+eSmCJgRC= zu05|L#?+#K2QKI4iM<>hkP^{eS}0(**LpqS zpgXJS8d3LyDBcjZzJ^_Im>B`?+>SEdGM~5G!KFcUj49ITp=K9B8Oq{lwUt6ppz}nT z+cVZ;R+ycsB!YI~o|%ih-wJN-dLd4JVJRa=x4Bv$+n6`P7!l4Vh#VpBNWZ=*Yt zf2$FVPw!1i?k_zI^4ufZz22L;qTRPrS3#0Oe?e8)bZwT zfcAhYihQN+F|<_M#)(va>1Kn|mDej-4}OEyrI~do!vkk{5!g=gX7uq}^oHU~(}x1? zgYLaRfT}d$DUV{37AuE#s$~s}aOrI0#$Gnc^0%9qUb&hVcFAmq_XryB|B0cpkUGlh zhX2y2A~l46viAyD_7xRL0o}E`oJ^2?ojSG*spweJy)#_jQzO z0$GFA&S<3&`heO7cv^P-&~6+V(U_;`ys7Tg z6~Y7I5)hVujbqz2u-C)eI*y-ZvhO#-G9g8Ih3j~F%ZZAlJp>T2;S&kCyDyH<^RL$i zr1En&>>dbVLWyM&FRQzFWm2Hj+c99g?b{#tUr6d~s)PY~(LE<{f$j7BuLlih>o|U< zQ@+RWe~g2_f6TI#!*E7UmUE9AnOdZ_@`uMN*q8?^;QnhIyRWlt9J`LdU-`#fCi!oi zv%mV8ee#cg_2a+ZxBF52GncQ6mYQ6sliXOnyP>k>ke3@r9asxHqilRs{p@V_59;3#Io z{V@&9I3PE-<2^s80n*Ei)z{ncI{1If7;fy^TldKs5N?sqd|9%;>L9!hNx+-9Mj{AK z+wGY)Y^)HMIPF27Q`R}}(Pwf-tCS3uN&|HByI=3Uh*=}tLOSBWsX4$_!kRn9ZgFEogg zQWA9S3digzEEu2VkDoMSZ&(%z{GT1k-~HuLGh@sUuohMF7j3V%sH5)GKa8bjeS;Xi z>wS!#J&%@I(Vmpp=k0(7M!Ud6}AiCLi1Bcw4}5 zn(l8(GGz+_<$Iy;mB@82yrRcg~9zm09heBD&LKyN(osi@q7Sea_ zxL=F*Upz5rUi7rk(K)g2TWF{HIfnN(T(cV70DRP=A-*#ki;WfRm-?hI#z>5(R!eOi z%I@e@8*QIw?$F7%Kec0l7wqk0X;1CA%g~q}H3?Jd;G@@9$d^wAY}hXiYJot(%;R)R zZD_g~jXd*RDMk<|C~9=POlpr6PsRq*+iXMtB87JDX!e?uj=lYveYfLnjGhQOk|J$` zRT}uz@Lk#Kn#nQH+Ay{9wzv#$pNFocZ2zZCjq_zxhg`~DxAZ3pspRq5NGZ9C>?v(o zrF#k~9{_kHYA6xdY+r5-JVZc5^|XxIT=X!ioOITOqM$Rwo5;D4#?D9~yn&*G|?_a_8KWy#~dm#r2 zK!2k4&ToJXh?-}=k=MzN7=X%@e6^~$*FCGD_ygCyszfz(ULc*ax7ycSuwx=b>Ug+2x_GGG^1TdId_QKmnrR+ZSJ+bW2+~dU=b= zF#2O(slxdz`SAJnAnawq+R9km6gtaTVS{}|4QZEE709oA`|z}5f`?2yN;x8j8nq0L zH!RrWNBRv16^C)vK%blJwu6}#M&i#a#z5X8-bI=tnOtG_Ss0Cc2~*CNvi}VLbRB1` zpsXu^u?X+-vS02+j!_rY{V;6pUv_>e--|~Sr{_Me%OeFTiE}o#?S7p+J|Zd6Z$tUigI;4M5{>&n=ENdEYdalUpB7 zPlzWBjRo=9{u9&XSNv~s1CKw8Z2tRP0QK=P+mX4)#jK>ueCDlUS#Kf(UFODev* zge$wB2QMbF&f{=v33V#|$u)g_inHF8Wj;LqH)VMma%Xr9Yo~Tx8b`TLv)NfdOEWI; z<`HtSw*bWi@K_$})l?mMg~>;mQ2Otl5pDS2h|G)hrp|EkRA1^Je%)yq(QAX#TTOH9 zxdv)_kgSXurbo`RINxuqO2e8$9Op4rZ}FK5eo>C4>85}08i*3NGbMUkHiQvQfuH9D zcyc~Ac{`*uLyS6&x06A2!f=<1PeaA>lS8mQ zj{JinZN7zp0_iUYl(kpWp}n;$k+tTIv25K(sZYaVGtKtrUS!3wpw??m_JDUW?byPQ z!nW0G<-Us~zB#u$+wL9dq!{vpJN|V70;ROu^f`d^p*7s;TNCd&9c=rN5)kS9Dft8r zJXXmOJD7X~w_$4?gOBWC(Yjw~?cbfe4IyOe&6*i?wE#se)_XrQFmTBJRM$V5m^z*B zyH;IrQs1Pe9d*7q$c=2%Q!T zH0MZ7R^oyO>-u03F{;~$p3M7VW2%J-Q zK}o?{v8Q+P1&F$~lQQA^!s{h8v+ipr&iRHkv&HA_2@qBcw3rg#g~R|f&)*>cK0OkP zJL4gg!+c?RDA9Z7kkM!y;DOk26f@W>iEltz?Gw(o>sFh`0cQZ~YHTU<$NmM7e0H>1 z?JK5qsvBtdj+hSAw*UiHtPCxZV;MJHLAmgPb?lxf*B>nZhZ0x@?1QzzswUU3U z#Ob&Q(gDgjSfhn`yWhyGQvhiMa?b|aO^xLU??phcDO!EvI6SX8dcCwh`gW}r{;|qc zM2K18Wu~;#(HVw&*t%DU9m|kmS-O}!`i|4PS&sPn#g}<<0w*HgBh4yxt*WI;15SZz z-oH5p$}sWm*a+p(YtK7*W@>O&xFGCE4dAFs~ap8NhYKqzS zq|bE9<*Eczw}av_uVwr83_(37uO|i{S$-JifV{kr&t8fys~{~ zhV@Dil>s~X3Co-jf+2L6!iRyx;=cI$MyG9;(r- z_gxejjQ@zr?PjK1H+2l)yd-x-KwVhkMtsZ=e&AiR9Z7m(h3ovMCC-uIw9L@5cA;cB`y|VXoh{k8 z#^V?tG;2<##3ymc=!50FtyRat9jp+jybk(E=7>z2C*mVd;}}liQzty!EVI;c^@3f- z(Q-NU2o*pAdO1iG!pvV^8^1i{M^zIa93PQ`>lzuJG3grlke%^woHcW;KJdA8bACy)Uwml~DFni&sXG(+^&*vORpl+?t)1-4Q6d6(Ib!Dy*VKwG}Moo)L5 z4Rf=3l>8664Piyd(Dq$q1;@^ax7Bc)zdKDq1Ix%D@jC6_ji(Yyh4O4OKWa zonA8A4Ym~P4S+I1$rvVOs*so(LGS0@Dks*u{FVEEK%QBdE9+R0 zyrj9NQ@|=ZL#M}_kIn-1_>B~Y-#vHevD2fLAF`BZj*xH%%E_P4@;{$6-jsZ6Q0CyS zJS-MV0(dOx8(f_wSCKI9K}{6Vt$b#ww?d!wgxY?hsWrM1$B>j7=G}}xf%;@SIom&h z`k*t?p8@ri8v{A-o19aB$>endVWw=O7M!s+#N=;rKr*R;uUwfdSmIxF?Si}1TZFMx zVXCcpw_|HH@XEHaT5~-T@teLxgZlQU2xAF~%e4~4{#cc5e@{P zS2`Mtgd2G(28Bv}kCa@o__>IB**4U>Vz%?6^J-cA2hVdnBYkDSunkw=$&uLpu`qW| zaQfD+$)#02OvE1teCU61UMHd?c4aff-w5Arj`z$PP{0wt8-HBfuV5{zm&DkK3) zB8cy$+M_ToPLJ)pv|}M`q2U1Lf(W*aIN)JSc^+A2v#l-~D($eU4j&;B$ESr(ra1>* zQ}C-vTgG2v3GpYkB5n<->#y2r+`mmV8P$Jw_cHh7cg_KiUn(EZMN7dWYZ}J8im-pO z6{!6rNMs{r8!oc+HJV3yoX={ro4>p8PO4yC6(M&;%FhUIT7x?=@UAm=$Q?B`Y^Gpa zXhr%b?61#bKg=lh!^Y+z{;YCr`Ov{7>RUT^mtP2~fB3xHCztu3v(EpUys-bNd;Nu= T`iEC{%dc4FpL>!?fA9G}a$K0( literal 0 HcmV?d00001 diff --git "a/assets/QQ \347\276\244.JPG" "b/assets/QQ \347\276\244.JPG" new file mode 100644 index 0000000000000000000000000000000000000000..c6a3f39aecadd284a9fbd91dff583ccc57dbca9f GIT binary patch literal 320618 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

^63n->IXYdh3B+Ar#(`8UEv~&_{~|3_Tjrc6 z9d&L+<9QNF3f%v-9Pry+A>AENxuEJ(;6;JwCpSYDiX3&_S1%HVE*2zr^yo)ULlTT& zkq!vxj_;L( zH`=#UuvYEr6(g+*n;{Y15e`Zdf5=g+hmSICzEb)d-^m_U58*!<`1rfj-3zF1ytDH^ zdOOdcrv7i;hZ;o%fgqiLpfu^dgr-uZgDAa8RUq_U1q3kx0-|)JixBA`O+W}mT0l@b zgx-4zf#2PpIsZFn&bjx^x#b0950hb%Oy;}xTI+c}Pw~myvpo1dw7Y5$ef938Bs(L9 z3>j7)OvvRqypAb?IS(F~Yhrse9AvmRHH3PW$mWS#WN|Hl{_=`k2C^a&jRgh`IsNT0 z*-BV!dBDu&uzu31p-#wMp2C{FLt|z+R@en3x?AFny{=3g&Ii_cuCr*3d6QBIENW5^B zdSw-HgM6eiuynle1#4;f+^cR%rUJ8dGzojln260}FY{caS!e~0qbYMlloV>vL2C(M4Vn&LllyVK62ym;^6Nb%*~6#I#hrKIa~XQ=KOSBO&qm=nh9I)!R_ zl~b&BjVM~OEg5B=-bntJ1YJ?4p&{*ZU5@7qf4y(9^NKu=%>gpg8!IafBRusc913c+aY<>2}}= zk2e8xEFb`MX}sFG ztkG&&b3vH~j-2T_E#LICvbr#RK@m#OA94oXP*WL#Gs=TA(wT$>I-Usc;`qKgUNkSq zSuTFOn8sp@@)(5i&|wVheTu~FsRFh0Q+J79W-)|s+IlhWAH=Vwr4x%=yF1PVZXSg&(Das z^L&TF>5`twha}HzE2#^?GT!pRhq8s?9Yb`cC&(ARLn@bvigr^-CSCV^+Qr9Zou7(K zCx6w&G`x8EqP_QeC%j$$Hr%R4@?>wa;Qeu`aRn8nLJ&w~G7SwGC~$P%{=UUSr0XW8>4i)y=N?E}*U2RX32Bo5 zeYOAuKor|kuB2cc-wkwuNar1z-Md=(T`{gV$bWFg*vz8OI=kG{uwNM9oejGfWlJ+F z6Vwa2r=MG>@z5K4m*sI4E%cjL$^cw+EGH0>ON&kZ($T>D?n$A&vu2L?7g^~&vDv~; ziEgWk(Vq2V$9bfwi8Thi+$CKCWMtfyMC+P5GU9q9<_j*83R#yfDxubVO+G{Aj*@oz zzbR!Y$^^ZVeZv(^v-)v2HjTJ~^O)l{37hFJR|6CKG&tf`&yl9l8BQ|t6p1(zh1BRT zn!yD%$dBA|YNL5qK11BEw4J;0H$F{jl)1d~P<{b+f#a`I@m7224t@V1mDjRDnR9Yq zm+r7r0)a8-YV%f+l*OOBJoa<$j=A-GKd+Kr-Eci3o~0($V%U(KSZw8VG(YByiW+gb z)cVPPA*-1_b7eu1URUT|uzpHEAyCWyZi#!Cy;tJQ;^H9zki+}~LJGOvEZklQDWN1M zF0q``ykxjUEAT#C5CYdlIP=g4#($%ZN^Bshuh<~?(#W5xF6wAWY5-c_22GY@lQe*9 z2kK5R=A+*f>c6`7n2q`k#@ub&Sm@sE$ODhE@26cZx5}<8f;-=C>aaWIe`%aR!mk9wA2u8eHS^wQncX2+2p7ZNAwE2;X!c$*VeleCgfb;W5!vbz&^NKpxX zgOusveZBQP@w}u&I7KFJe=BS~w`s(0Bg8OOp_R z>?m4x;hn;uYXz~gY%o5th#s7{h+L`p!w(17WC~;yMb?~1FBS1)AYJZoe@F%|x%B)& zK*3F6BA~gj$Bkl>cw;oAH>g}Zb1s$)#WEdh8LUi+v`PpS{*0Iw;cSr&FC}Ri^29`$ z&2*(@59w9b(oi>8V}7f%tWOb#+U(M(vsc%B-fL8vqE1D3wq%F9;72S=)^P1xo9!j1 zY^^osI**D;P}&b105=6d?O_ydsv@oKgj^Eho9_x8TS?AcV? ze*M<3S&m;DlE;l#gWdGoM52tfK%tg1e6mmC`tV{KLosu8irqsoT>|Ak?|+FeGe}No zFt6sEujv6c38cxIS_gm_=a~p^e#j;3_XCKmrPwfx66dfS@!uFc03WZlrk{Gtr{>T**kU8?q-=zDBcE2_ATm9=}bssr3(3d2Z zNamz5%G$AsgVcpEM*sYF(=UOTXdhnhsh+*3&kziBOFjc3yLY}h%Y^ytcr!i+ax6fHlf@A9q+qGGLrua`=M`3_GiR1(ye_p-d zxNWiLy4b9bDR9;QV^x3al{eGff}6PD_>wRZE440hvF@txn|Gx+QX;RN+-(gkXKbHz z`ALX{zPA;wWqt63#lESG1^^``b^J%k+5d~{Fu*GWq&)zJ-tjgkMef^Z85T!$3k&-^ zd|Q=Ld1yiB-@A<`hY6wLHK6cScHdk_mIEht7RTEAvz|JD-3)R&&|oCNy8uM2zN>V@ z@)aQ3qI>%yM6|sv(6i$EK}(ZgS?hy+Q|CA1l4?>9WMC;_@BC|$<+0*btUrGw>w3Db zi@q$*x-fmK6FcpJp*pO6Q&F?lbdJBpRrvtJb)bC@V)7eWKn5{P)ncJwW-=L}h-+S~ zAc}~XOfq8sUTh-1>>HTEbAT4PP9drTDlDq=%>?PT2q~lV+-@|4;L=T%9)i@^vBN~# z8c3YjMqfvXU|WB_BIi+c7eVcyMRijys0TKaTd zqikCAM_pyumk;40zx~jGXV7`nXIIJHyHt0_@+E`5E`|D|Ii-KvMd!(4*V<^CZfOS_ zOdToIooO#T+B=P97wslJc=uCt{y>A}l7FN&L}yNI)J;OJZi?>P9qx4#_BersXNfj? z))Z%RC*RIWg73|ri_2Zt94fhsOk?c6Y6d9EX>gzsDCMgfHwgQ<)FrR&$NQ@3NKy75 zkW<*33B}vNK|!)TmXnP3>M`4$PA_kU5;t33ldKp;$SwyWHDibbe(u6$W}1^VcC?+n z8Cc8Ks=m;?rgeCZ;7@<5s(sw|khbqKoD&ux-Ob-E|M0VzT(Mk^^lEO!MHkbDNU66a z`tM1a9GahMu$}CpekQ=T#4h=t7?l@4b&V_z(bYZEU*K&vMz^~e)$sX=y_zPDipu#h zv0)XPAFEx1n7pUYtaCGi z(&&C9oByZHuI&456M|+6UW9xZA|o>M5GC@~?91F{mlIiUHpa@7*ruC@bTFfcgSwzZ zU6S~-3PDx5uK z?IN&|{v?ESN4f`s^0cSb+MC12xe<7*LBowqc;?6iYOX~xZ5^9v?kkCk(&oZtE+Vnv zI$qfDhR_s%4S;Y4HFm>i6R;sbUSSPc*Xn4wWCG&j%7^C~tZTG(hmSefeTv+>RlSrl zxVVT=8jT??>;bDS+<+$Dgf{W=4BT=bmtb!gQp$557c0+}RVp^91_{j3)S2EVT$WNS z9xJRwOhB`QQSaFzGj*Ap0`<5$6Z8>qC2MlrlQ~4n^%~xVZwHD@dgL=RYNd;)@Ml7% zZn%0I93;-|`}3f9w?#^&E)JR8%I;hI9~-Z0VaioCh5*(JUhgr6B>S;&y)-IKA*!T23L=kABVmqFaccD zxHI}6o8+i{*+0#Sp;M6Qit!qm`Dzi5&WYFP5do+vwpqDYxooXoBf!zK3HM$s^~EvW z!C5A&rr<9+Ba>nBKg8CcL z6_zVrXm(-(=#!Pi{VUv~U>F3+=mycK995IrPM zk+jDg(GDG~^l_f+*OI<==qRTqjT>*w5P$7<#QMohZQ(Zg@;wOo0y^5GD#2^Jr8 zm%Q5G`Gy)9_|q@^iR4edAX&Z}0ihPxB($H-X;r^JSbh!fR@j#haowxNo&J!yx_frA zxFX6lNm3;&DiWz1RvsD`I&MXa+sld0QL9X&mwGKoG^w&J!`Ws^Kvc$<#RkRR`<-2k z8Va6RWwc}+FAsgQl>96Z=wR0GlrR2aph^UztqPxx3677??69n|ip|zKSQPiOgv;W% zIcJ-zyC?fpK26^5wQ7b@%1%sU*UkW%utCxD`1?fWfFu3#*Q>>-~#iG-ml6 z2OK^D*Vt_!OUK7_%kcv~UX?nFXVO;a@(|pfNrzURlU7MzgkzJjOg9#Sh&@Czu@QEL zitkw?9TZM*r+CeQRqt zukLQ;%K341w{^V2%rA$NPX2P{2inSIVenbbVSJ^S+pCYCm!b|3Vpc_Cn$$*%VXCT` z2KtdTcAx0w7c&lpd$%?EJjk7fKx{HV&%08;1Ldc=C61H#bS|)lYFa9ttCDGdhucL& z#Va3V+Ge!d1{$owT--!3x$dSm>xh(skPJz`(HH-!3ksQC1L4UO)UCJnU3j?Bn5*g z#3HoU2SaOO$@ZM+x&#iAYdQijhT20vLvFE4_iCDO^dy2Pp~eq zyYTM|DqSoU8zqxOQ729lD}(<1Zmcb(n(^t&$=?*j-k#O-^p{Alcs&hs^u4m0C_Q!D zy14LOQ-s{B8Me9RsMM9c_9Do{x~XB3>ux@^Rd-%ox2QTvCdF|U^v7h~ySo_yA3w3$*=pii!OF+zY>dax7rT1C zA>W`~A9wG}^V{8fKu1pzlF_y>irvE7#xK?gF*~PMo%`LaLlKSq28F&}Y%)E+sd}f7 z*K_QtLkfRKK|tcRMjL2wR~BrB5MC z^RGbR(km%3IEK?=z26=Aps!p@#DPqHTnW^Oqu2Y0;==n618+HivvWghiQpYayYZ=+ zY&n|cDG7FH!}RW#9iC4R4-X?}=yQ)H9%m$=#`X;~jVhRzZL&o+^_uJ{MY=qD6O)*Q zL6!3qgCphkzkC=4-*AL(5QCKylFs7a8h@<2mua;rs556y(thOwL}*YnvwZ8Wbho|z z;nmjz;dx%%#HOX7&&ST|D#k@8FcwzGF7HcZ=@q5F)&=t;jUvY6`CS3z!gtJQl4VYX z%kcV1niQ%I@B)574ZkAI&e5zUz9FYn`L3yf;Rv17<^qjV+8X# z3~u-Nj6_|Flhon^ZB(C@9%A4QiHd zUY57^Vob(va7gvcW+8v^mM@ivay-??!}fU^*`SHFr|(`0e6e|LEyQp{5oi)g;Myx4 z@%CRzr5N&^`asjr4KBvECeRGuwlX}`16>U5jLa_dJMfvqlMYOe+w zf2b*eu#bH6VxO%R{`sc{r3XM*vFvC?p3N*4ejT;jJ1(OV#eD=TdVx9jxtPw$7wWCU zGAA|}$%*s}2L$i{rRQRf=mlHn&3yyQV{Q7BAi~^|azrl8X%U%NBCi3+IA@WllY#pE)Q&~T5D%C$W-OCJ zCDc5dPb^txTPcI(+0J5Cb0}LaeOs{$rO0l!vw617vn9N3q{im#yB`k8;SB&{YKoQT z=q{?bzJ-G#aA`jswoa~&Q3+T~q|V9*j@s7jnub-@0Sb831mtJTt!&V?5+$d?^lG{& zr8<6;Qu1cDuJ})!wDbUf; zezW+%eGQEU@1vpvDj3f_WYHb|?4x+!1fQa0O89uB8OtsLu)z5A9+zCLe=oq%NpWVv zIa49wNr1Iq*HlwG`L_=w$S)sn5U39aKQTBRU}V7tVd=UGP5_>O+us8XI2nMuRv$K| zJ;ykLMF1-@_UPPgDRG{T!Kw=Z-n4QHmb#307Yr^}!<@#@^$FL#uJDj~;S~#pNuPe! zZ#cTxgV6T5Tg|NVW;|O2Sg{)T{pY5==Yt~=$v<+&n^4)3 zizr`84O}624-sxB^A|K?vC_wN;8!^}FKo)s+G{Lfem_27HLpu5dWo_*UB8BaYvIf! z{UF!gfjFLaQji=wDps#BpEjfX3{N_Og_$m#4Jw~>Ny&#}NPUjJh%mVL*!AmMFzfvo zOli#B3ehfb^<^4k3qh?iOc(D8hPaxx>Q=RU``TcZ;Vh{h%N~DXMd^PvdHAaC>myok zN}@^3aaZuu7oDTU0VBUcxqrVnU*Zd@6%UJ8_ck<69TUC%{fIN&C-~3q|El%)@BZy? z$mV~pM4wGgPbObgn@@i=*3)e~p%a)HyYqC{$79Ma!9INtP3<3V;j$k|oOoXa>2A1d ziLeMy4G0hz%3C1B`}d`=f$~g?Ww}Z4#`HY6q z11M~Yil6mS8Hfm5o24y&KZbSo;0{oqb(MH2cZA`aT2H_?mECmN^~8C4dpOxrzSHg` zWG2`L1!4K6_yXFy)sBn#-gUAst65^iF<+NSZ;Al%r-EC-(@+-`BKGW0i806&`wE%u z-PuGDs@V14Cj~?));`>d(WU3QLnP)7BEUK~iFY0>Fj#$RZvvP0y@3?Xrr189muMT8JGi-_V5~|Hd zQ&azV&o7PX+o?qCq8)xw>|Q@mk=>C;!0;xsZRE{dc-4e7!&0-ixmq+Itgqv;3+(6) zr8?(s-Pktm8|pt4D3_#%iPZyHEGw<^bvYM8nh9ilbKaD{(H-)tL+2Y0xGdkAT&Yzf zk=36{I(^M1eAFL2SZzs+MsP{5x)ZlCDaf21;4q<*4R@a=5B904ck7;h4Pzq<=>&X( znyAhzx`wJq<&(Fy*B~sSksWQK>`$#7Qg)IJ8&HE9E3I;|UoEl4_3!)bRu6eEDEN|R z&G0mj*@h_tDYL-K&lEVvK4HDj-JZAF42#U8x)mvFN3v57+kT*F1O|qF+n_|IZqjc2 zk-suNKKtBvyK%vWM;4`i$m(bEer0{h4#g=Vj|V!5tx(1@mseg-BZAR0r4N?VI2m`s zm=1p9f|}mtm$6Lz$+^}nKk1g9CMtLjwbFaF6Lx8QXl$nS6TdcUq6a&CRE3a=moQv@ z{QcZh)(=MJdoXRbK2E#gXMb(s=}XifRc+ff-}xWUbymElzG4p15@!>OIa}L;Fydc5 z$@8pdm>G~Yw8C|xAxy}p%&R4BC1m23{Vx5R;uyqG7*{=kDzn*f@j5}dVrIjjk|Tpc zERi??7(F&Twbg;=1Xjbjr4`>9FbtK@;e8zY>9nCE`w4bV?WX*XniCtRy%0R$k_}#R zFkoNz!L@jrS1!llYK61?3)aYZ2H{HPM5KCNYJobQz+FB_q>KINxY&DBJ%9!N(8ijD zLN2&@m{Ms#qDq#@gs3Z=M11DY;K;!JMSo72f^~%APz!(j;(e4cR9x?VS1**8Pzu&pV?kk2Io*jL@@v_L^hfbnTqcE^@4FdoVpa@b zOv4>srDR0Nhu%+$0|gD=A9f={%;pzz?l8ba*0pa%9Tf;<=9rp@c@BqeC9qvDdQY0o zn?IYJ+Uq&2r@n${ac+cWkvc@WNhj-Q3)fMZQyzW17bB}DdVQ#nxPeBEGhG@Cgj6AY z$-xV%@ZL>jmX7x~XUC)l5H2E!nh+N^HOch&K$3I-jnd|#Gv+N*=;_9~M&LOr7<8ss z#OlfFIni~B8|W)l0NVuOe@lDO^Y9vP;cr*GM)1L%mAd$p>V8uBO4 z-%4rk*Vmen2eviu;2napLC59z5oOME)Z5^IpZoQN;g;Rd;GCi2{#_ZN8)wWNvy|0Z zLR9O+lXq{v;56pmP@)^RcVry^y*ED^0C|Y@vTh(d%NF^JGfEA#>wj(h==NkzbUJ^- z4qw+PnkP1EA%E!4f>zFq*wo$NvCIkRJ$* zi{UH~Yxroo>cww2<-+ra)YFIR4eiqH@{1oRL>l&i@UW#NHs0LZqRoEo$GHG#F+Y>? z=-O_x7%pgl|3&SrV=ea?@@Jch7p6AoT}+;1sag3zN*SLpIPyB<7JT@^r0H{H z#}Xa}qOv*XeHcljzAaJuEC}6PxQ7D>ZbXlRz$oNIbS*!*>Drh2Mv*z`5(VR!2_NM;Q5`xUE{4U}% z~}DhEE>_203DLhKMR%a@*Mb>m!Q^a5^_qr0J`{`vcq;_pB!E@9ONu4&!l0)vixfL5) z_CXV!tYqFzJUbOeQG(b2QtIjbW3*Iw&bJk;EGEmE(0RjW1#_8bWF#ca<@=rPHn?JT_Y3h7AQN!dg2D@F! z>?a_S83hCsj0XdkP6@948`6onGPVFkIeR7hXG!6Qc}fild??i|Ch=d=M~blS#VnVK z{0%QQ0U)@ipt+N5dK;9ZrxT`m4mN2Hic{xGp3d1rKRJ85XcHE^udn#6b;2jjxUhoHBWYy!!a7<%jg-SPA`7A!^b=O6P3U+U$EvO}V9jI-0bZ=4 z@=xy=SPafR(9~IB*`JF)GsG}$Zf4(YY4xSdw);$-^NnE}I25%B_WQDH-)Pp~SJ5>z zeFsT#h!GIi&~GaWUcMT--)7U}!51wM=)QUB6sF=qX}l$j?a~Mu9SMsL%OJ#8{9LL$ z?vf&DVI+l*XJm`=S9k*bnty5(7~zCjRSQOt320d-Ql@0Bkw7BC8FRsgQY?|OOdcH3 zB5&4Y(TN$^|vP=bDgXDC9zoUhkX~oUA$F!WDC}mG76hhX?syxr+ zY#jjTA%@t;EdGi>P3{_ey)YwNQ*q;;uuy&Nj(6Z)|43a`808=Xlp}3BL@!tNP zG;CnV%t$(X{nk+6^@c?cF>U#9^>t;p*_we)lGa5=ZexTn*jK4<>=JS#8=KZ=W6eu20rxIJP- zp#cL#Fvb^dmV)G?W4H+g>)ofg^y3{>Ib$$Uk1a@i1w)#AtfhIZ@D`B{yA!+s_;4r zZ!)KN3(&OzIcNS))sLanO&b$&m645B0u}*Ww{nk9(dbv@uf8nYHhuK zY0L~AV0n(yasTLLSSa*D`v`CZO0~_{rp9EwC^9Q7f6aeWU6@Xd&NrSnCrMLBXL|$4 zKGh+2;xY%kraI~vwwl`vUTQKdaHU()wgCBZbv9E~RV-dRKLH-EpXmjJPU!c(w8ln6 z>UgDty2PVNoMBExM;}R3k8+o&QXJlgGyIYF#+BcwA#|2P7U9T1VPL`vid|U?;}eMt zSQ<%SlV)89B4W%YAfSeM`tHYM-@-*7GfcM$6L>+>GBT^RAh)%^<&{`p!Ez)x#&8&^ ziI>tE+xBsN++6djXBuj^Zp9ywkYl>l%(y7y9kdkjJLCBvqsDjAJxahr9FeuGSpzGe zZ*HTV={=Ovv>bGw35z&_LE_uPU&w$H9}9#Ahcx_OaO?ba<#2#d5vpn|-j~iioM5`Y zRn33~)Vs#(IuLBLXiZ%+Ao-+?Py+{shU*;*g->0mVGoM=OW%GeHMB%m?U?NQ#lP1T z)2MV~5bfz~SW`j^`*O0gHRR1y=9tI7P7bX-857>mr+fyjTRx+BW~%v)ZsX!>w^L71 zLN<(7SWP-VebvwwCo`bI@?*UU;K&9wf}`^r=p+<8SrONac1n zoPccDC@KH}71)Tp{0F~n6)flaPtd{N-&Udpm@Gk@0I5OtUp= zsD44mq99T%TpEUOCb4D*v*QuY&vhh^cdl;*>49c#2B&X&pW?CX6cqFGY-Aw*)gtDS z9rdE>LuBWEDeAsXPsJR6oit;w#Em9H>Znbj{U&!4L1bA93bTF+eAq+q%_7e&~7Uw}1vF&c%^SIvp`K9{gC zu+Vw*Q=jz>6`BRvGclHZ6Z>BJ(d%0Ww3&_!B*46ke#E9Ka&}PI*l^dbLYMnkV#oI& zgWo1n%Cqr^VMC#Xe^2+em-ExhG1=;kVlqv>K_$VLeLOaPqLM5Z(Ra?$u5_>52YVnrRNhvCD;U6V}F+Rb8T*o zB)YaBzON)xfaOkh>t2%0yF#yMJq`5xQ1-I~7kcc2SKZG|7}u!4>GL``6Je-&p*e5Sbu_o8 zX|8HxD6N&lKd)JLk@@YOdW3@d*omITl|%EO+H}|FU!94Pr!csYI*tzi&OQ%l)UbOA zwkg)-kS~eEvIa**$zq73ma>##shc!B8`4FGnUuWOS4rwOH5VJUq8V6{CL@&q?2HXk zreH{h#b{bk=EDvM80EI`$|4IvN31}HlDpah&RNz-aD?%O#d6k?lFRy$BLa>Kfc^@f zO$hY{wOqD1Yi#L=;q}LmE;bHR*&mK~)!CxXZe%ydJ8?mkK`>7}OQ#9DG%piUuYpx?#bP?NPLv#X&j@K)n*`r(Gm<5<$u^h;lFL`ysfBQE$@E2W6GMD zhGGdWky&X|3H{qqB?g$rB6pu05bOR~;G=bBAgW^Kmfv&TMpF3S=xC*=M09r6U4QxJ zb0f)$oGOt-fwRDr;*G@|Xw}xe_2m(tf^XZy z`f0JDui#9>{4jCUpvc*%hMW$rel`c=!b8*)PQqQzE6r{vQ^1{RhcwlDcoT61vIbyy z>q>(11b_=lw6P~O77G{O1Tn#`;{Jf;Alj9&jv4XxGRwe|6}6&Z zw}SsD;xYJiybjxJ80S$NWh>vD&{%HRFEs9nWl{FOKeoowHlA+g78jD_<{ssG(+!?b z=6~AYn=yJ@Qsz?&eZAR9;CKvqTD0(YVyzw4F!xZWsBPLkuP7#deVpo4_W%OK2AI%a ztl~#eU!XfVOT1-Q6+)*&$Dbvx+C-Om*LZn#mCcW(km$88U4WWV5)S0{038#M)h%K` zwTK^cyix#P6raZ@hS87LIT)_lOR4??iZFiOHV*APH!fP6+v6*f!grp9@hyCLVd%*h z13jm7p4)}4)Ji<0BE*XCo+1xT4=d-|)AD|$g)u1=U80gL5eR)$pZv8-B5^*L8UV zAA1tJS@;iVg6>MoO6ciF@I~98RfYodn}0yF3hF%*ZA-N9tF!+g~OOy7q$r@eE|j$^OBAy+L~ zFCGCO#`NZL`5%z~Sn;k9P9NIb zw#%fFxU``Vdp_#8#@jmkG`f`k*2WBxD)S zgnkO1waWW^^icwgIqg!FtsgHy?#3thxR;Z=+jCrW?&p0&mVDNL?9zzTj-~DSW^1pi|=QhEQuE+hl zs=>bmo>M^dAM{LQ+hSKLl5NMo6hEL#^Zo%DLND^qP5NaW39ny;ZGHy6YK9N5iWE=P f4$z3j@`Xc%dVmL*3`{Z(z@z_q1ONTS#h?EHr~GQh literal 0 HcmV?d00001 diff --git "a/assets/\344\270\252\344\272\272\345\276\256\344\277\241.jpeg" "b/assets/\344\270\252\344\272\272\345\276\256\344\277\241.jpeg" new file mode 100644 index 0000000000000000000000000000000000000000..35b73f0e1e2b35c6a1bc0b28e7f385084dd6a9cc GIT binary patch literal 187205 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

l4EZ^;-yTpg7< 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∋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 A{{R30 literal 0 HcmV?d00001 diff --git "a/assets/\345\276\256\344\277\241\347\276\244.jpeg" "b/assets/\345\276\256\344\277\241\347\276\244.jpeg" new file mode 100644 index 0000000000000000000000000000000000000000..abeb9aef11230c884eae2b3f06f43657fde3bb8f GIT binary patch literal 157149 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%0DgFqdY9hLsqO@RJkCXE03$Y6gjxFf1x`UQdD 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⋙At4#tz-yaKFB3()Jfaqy(EtI#u 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 { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count); + } + + private static void add() { + count++; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/HttpFilter.java b/concurrency/src/main/java/com/javaedge/concurrency/HttpFilter.java new file mode 100755 index 0000000..aec3df4 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/HttpFilter.java @@ -0,0 +1,35 @@ +package com.javaedge.concurrency; + +import com.javaedge.concurrency.example.threadLocal.RequestHolder; +import lombok.extern.slf4j.Slf4j; + +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletException; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import java.io.IOException; + +@Slf4j +public class HttpFilter implements Filter { + + @Override + public void init(FilterConfig filterConfig) throws ServletException { + + } + + @Override + public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { + HttpServletRequest request = (HttpServletRequest) servletRequest; + log.info("do filter, {}, {}", Thread.currentThread().getId(), request.getServletPath()); + RequestHolder.add(Thread.currentThread().getId()); + filterChain.doFilter(servletRequest, servletResponse); + } + + @Override + public void destroy() { + + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/HttpInterceptor.java b/concurrency/src/main/java/com/javaedge/concurrency/HttpInterceptor.java new file mode 100755 index 0000000..4ed6d77 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/HttpInterceptor.java @@ -0,0 +1,25 @@ +package com.javaedge.concurrency; + +import com.javaedge.concurrency.example.threadLocal.RequestHolder; +import lombok.extern.slf4j.Slf4j; +import org.springframework.web.servlet.handler.HandlerInterceptorAdapter; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +@Slf4j +public class HttpInterceptor extends HandlerInterceptorAdapter { + + @Override + public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { + log.info("preHandle"); + return true; + } + + @Override + public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { + RequestHolder.remove(); + log.info("afterCompletion"); + return; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/TestController.java b/concurrency/src/main/java/com/javaedge/concurrency/TestController.java new file mode 100755 index 0000000..bc49c01 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/TestController.java @@ -0,0 +1,17 @@ +package com.javaedge.concurrency; + +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.ResponseBody; + +@Controller +@Slf4j +public class TestController { + + @RequestMapping("/test") + @ResponseBody + public String test() { + return "test"; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/annoations/NotRecommend.java b/concurrency/src/main/java/com/javaedge/concurrency/annoations/NotRecommend.java new file mode 100755 index 0000000..b1f1268 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/annoations/NotRecommend.java @@ -0,0 +1,16 @@ +package com.javaedge.concurrency.annoations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 课程里用来标记【不推荐】的类或者写法 + */ +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.SOURCE) +public @interface NotRecommend { + + String value() default ""; +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/annoations/NotThreadSafe.java b/concurrency/src/main/java/com/javaedge/concurrency/annoations/NotThreadSafe.java new file mode 100755 index 0000000..3413bd8 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/annoations/NotThreadSafe.java @@ -0,0 +1,16 @@ +package com.javaedge.concurrency.annoations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 课程里用来标记【线程不安全】的类或者写法 + */ +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.SOURCE) +public @interface NotThreadSafe { + + String value() default ""; +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/annoations/Recommend.java b/concurrency/src/main/java/com/javaedge/concurrency/annoations/Recommend.java new file mode 100755 index 0000000..6e8c350 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/annoations/Recommend.java @@ -0,0 +1,16 @@ +package com.javaedge.concurrency.annoations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 课程里用来标记【推荐】的类或者写法 + */ +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.SOURCE) +public @interface Recommend { + + String value() default ""; +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/annoations/ThreadSafe.java b/concurrency/src/main/java/com/javaedge/concurrency/annoations/ThreadSafe.java new file mode 100755 index 0000000..c38ef6f --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/annoations/ThreadSafe.java @@ -0,0 +1,16 @@ +package com.javaedge.concurrency.annoations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 课程里用来标记【线程安全】的类或者写法 + */ +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.SOURCE) +public @interface ThreadSafe { + + String value() default ""; +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/ConcurrentStack.java b/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/ConcurrentStack.java new file mode 100755 index 0000000..49129e3 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/ConcurrentStack.java @@ -0,0 +1,53 @@ +package com.javaedge.concurrency.cas.demo; + +import com.javaedge.concurrency.cas.demo.Node; + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicStampedReference; + +public class ConcurrentStack { + AtomicStampedReference top = new AtomicStampedReference(null,0); + public void push(Node node){ + Node oldTop; + int v; + do{ + v=top.getStamp(); + oldTop = top.getReference(); + node.next = oldTop; + } + while(!top.compareAndSet(oldTop, node,v,v+1)); + // }while(!top.compareAndSet(oldTop, node,top.getStamp(),top.getStamp()+1)); + } + public Node pop(int time){ + Node newTop; + Node oldTop; + int v; + do{ + v=top.getStamp(); + oldTop = top.getReference(); + if(oldTop == null){ + return null; + } + newTop = oldTop.next; + try { + if (time != 0) { + System.out.println(Thread.currentThread() + " 睡一下，预期拿到的数据" + oldTop.item); + TimeUnit.SECONDS.sleep(time); // 休眠指定的时间 + } + } + catch (InterruptedException e) { + e.printStackTrace(); + } + } + while(!top.compareAndSet(oldTop, newTop,v,v+1)); + // }while(!top.compareAndSet(oldTop, newTop,top.getStamp(),top.getStamp())); + return oldTop; + } + public void get(){ + Node node = top.getReference(); + while(node!=null){ + System.out.println(node.item); + node = node.next; + } + } +} \ No newline at end of file diff --git a/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Node.java b/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Node.java new file mode 100755 index 0000000..8efedc0 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Node.java @@ -0,0 +1,20 @@ +package com.javaedge.concurrency.cas.demo; + +/** + * 存储在栈里面元素 -- 对象 + * @author JavaEdge + * @date 2019/10/18 + */ +public class Node { + public final String item; + public Node next; + + public Node(String item) { + this.item = item; + } + + @Override + public String toString() { + return "item内容:" + this.item; + } +} \ No newline at end of file diff --git a/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Stack.java b/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Stack.java new file mode 100644 index 0000000..f118e6c --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Stack.java @@ -0,0 +1,56 @@ +package com.javaedge.concurrency.cas.demo; + + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; + +/** + * 实现一个 栈（后进先出） + * + * @author JavaEdge + * @date 2019/10/20 + */ +public class Stack { + + /** + * top cas无锁修改 + */ + AtomicReference top = new AtomicReference<>(); + + public void push(Node node) { // 入栈 + Node oldTop; + do { + oldTop = top.get(); + node.next = oldTop; + } + // CAS 替换栈顶 + while (!top.compareAndSet(oldTop, node)); + } + + /** + * 为了演示ABA效果， 增加一个CAS操作的延时 + * + * @param time + * @return + * @throws InterruptedException + */ + public Node pop(int time) throws InterruptedException { // 出栈 -- 取出栈顶 + + Node newTop; + Node oldTop; + do { + oldTop = top.get(); + if (oldTop == null) { + return null; + } + newTop = oldTop.next; + if (time != 0) { + System.out.println(Thread.currentThread() + " 睡一下，预期拿到的数据" + oldTop.item); + // 休眠指定的时间 + TimeUnit.SECONDS.sleep(time); + } + } + while (!top.compareAndSet(oldTop, newTop)); + return oldTop; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Test.java b/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Test.java new file mode 100755 index 0000000..fc6a42d --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/cas/demo/Test.java @@ -0,0 +1,41 @@ +package com.javaedge.concurrency.cas.demo; + +import com.javaedge.concurrency.cas.demo.Node; +import com.javaedge.concurrency.cas.demo.Stack; + +public class Test { + public static void main(String[] args) throws InterruptedException { + Stack stack = new Stack(); + stack.push(new Node("B")); + stack.push(new Node("A")); + + Thread thread1 = new Thread(() -> { + try { + System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(3)); + // #再继续拿，就会有问题了，理想情况stack出数据应该是 A->C->D->B，实际上ABA问题导致A-B->null + System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0)); + System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0)); + System.out.println(Thread.currentThread() + " 拿到数据：" + stack.pop(0)); + } catch (Exception e) { + e.printStackTrace(); + } + }); + thread1.start(); + + Thread.sleep(300); // 让线程1先启动 + + Thread thread2 = new Thread(() -> { + Node A = null; + try { + A = stack.pop(0); + System.out.println(Thread.currentThread() + " 拿到数据：" + A); + stack.push(new Node("D")); + stack.push(new Node("C")); + stack.push(A); + } catch (Exception e) { + e.printStackTrace(); + } + }); + thread2.start(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/Timer.java b/concurrency/src/main/java/com/javaedge/concurrency/common/Timer.java new file mode 100644 index 0000000..caadf6d --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/Timer.java @@ -0,0 +1,24 @@ +// onjava/Timer.java +// (c)2017 MindView LLC: see Copyright.txt +// We make no guarantees that this code is fit for any purpose. +// Visit http://OnJava8.com for more book information. +package com.javaedge.concurrency.common; + +import static java.util.concurrent.TimeUnit.NANOSECONDS; + +public class Timer { + private static long start = System.nanoTime(); + public static long duration() { + return NANOSECONDS.toMillis( + System.nanoTime() - start); + } + public static long duration(Runnable test) { + Timer timer = new Timer(); + test.run(); + return timer.duration(); + } + + public static void main(String[] args) { + duration(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/closure/ThreadClosure.java b/concurrency/src/main/java/com/javaedge/concurrency/common/closure/ThreadClosure.java new file mode 100644 index 0000000..d803764 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/closure/ThreadClosure.java @@ -0,0 +1,45 @@ +package com.javaedge.concurrency.common.closure; + +import org.testng.annotations.Test; + + +/** + * + * @author JavaEdge + * @date 2019/10/9 + */ +public class ThreadClosure { + + /** + * threadLocal变量，每个线程都有一个副本，互不干扰 + */ + public static ThreadLocal value = new ThreadLocal<>(); + + @Test + public void threadLocalTest() throws Exception { + + // 主线程设值 + value.set("这是主线程设置的123"); + String v = value.get(); + System.out.println("线程1执行之前，主线程取到的值：" + v); + + new Thread(() -> { + String v1 = value.get(); + System.out.println("线程1取到的值：" + v1); + // 设置 threadLocal + value.set("这是线程1设置的456"); + + v1 = value.get(); + System.out.println("重新设置之后，线程1取到的值：" + v1); + System.out.println("线程1执行结束"); + }).start(); + + // 等待所有线程执行结束 + Thread.sleep(5000L); + + v = value.get(); + System.out.println("线程1执行之后，主线程取到的值：" + v); + + } +} + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/communication/ThreadCommunication.java b/concurrency/src/main/java/com/javaedge/concurrency/common/communication/ThreadCommunication.java new file mode 100644 index 0000000..b21f240 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/communication/ThreadCommunication.java @@ -0,0 +1,227 @@ +package com.javaedge.concurrency.common.communication; + +import java.util.concurrent.locks.LockSupport; + +import org.junit.Test; + +/** + * 三种线程协作通信的方式：suspend/resume、wait/notify、park/unpark + * 原理文档：https://javaedge.blog.csdn.net/article/details/102345871 + * + * @author JavaEdge + * @date 2019/10/8 + */ +public class ThreadCommunication { + + /** + * 包子店 + */ + public static Object bunShop = null; + + /** + * 正常的suspend/resume + */ + @Test + public void suspendResumeTest() throws Exception { + // 启动线程 + Thread consumerThread = new Thread(() -> { + if (bunShop == null) { + // 没包子，则进入等待 + System.out.println("1、进入等待"); + Thread.currentThread().suspend(); + } + System.out.println("2、买到包子，回家"); + }); + consumerThread.start(); + // 3秒之后，生产一个包子 + Thread.sleep(3000L); + bunShop = new Object(); + consumerThread.resume(); + System.out.println("3、通知消费者"); + } + + /** + * 死锁的suspend/resume + * suspend并不会像wait一样释放锁，容易写出死锁代码 + */ + @Test + public void suspendResumeDeadLockTest() throws Exception { + // 启动线程 + Thread consumerThread = new Thread(() -> { + if (bunShop == null) { + // 没包子，则进入等待 + System.out.println("1、进入等待"); + // 当前线程拿到锁，然后挂起 + synchronized (this) { + Thread.currentThread().suspend(); + } + } + System.out.println("2、买到包子，回家"); + }); + consumerThread.start(); + // 3秒之后，生产一个包子 + Thread.sleep(3000L); + bunShop = new Object(); + // 争取到锁以后，再恢复consumerThread + synchronized (this) { + consumerThread.resume(); + } + System.out.println("3、通知消费者"); + } + + /** + * 导致程序永久挂起的suspend/resume + */ + @Test + public void suspendResumeDeadLockTest2() throws Exception { + // 启动线程 + Thread consumerThread = new Thread(() -> { + if (bunShop == null) { + System.out.println("1、没包子，进入等待"); + try { // 为这个线程加上一点延时 + Thread.sleep(5000L); + } catch (InterruptedException e) { + e.printStackTrace(); + } + // 这里的挂起执行在resume后面 + Thread.currentThread().suspend(); + } + System.out.println("2、买到包子，回家"); + }); + consumerThread.start(); + // 3秒之后，生产一个包子 + Thread.sleep(3000L); + bunShop = new Object(); + consumerThread.resume(); + System.out.println("3、通知消费者"); + consumerThread.join(); + } + + /** + * 正常的wait/notify + */ + @Test + public void waitNotifyTest() throws Exception { + // 启动消费者线程 + new Thread(() -> { + if (bunShop == null) { + // 如果没包子，则进入等待 + synchronized (this) { + try { + System.out.println("1、进入等待"); + this.wait(); + System.out.println("wait 结束!"); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + System.out.println("2、买到包子，回家"); + }).start(); + // 3秒之后，生产一个包子 + Thread.sleep(3000L); + bunShop = new Object(); + synchronized (this) { + this.notifyAll(); + System.out.println("3、通知消费者"); + } + } + + /** + * 会导致程序永久等待的wait/notify + */ + @Test + public void waitNotifyDeadLockTest() throws Exception { + // 启动线程 + new Thread(() -> { + if (bunShop == null) { // 如果没包子，则进入等待 + try { + Thread.sleep(5000L); + } catch (InterruptedException e1) { + e1.printStackTrace(); + } + synchronized (this) { + try { + System.out.println("1、进入等待"); + this.wait(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } + System.out.println("2、买到包子，回家"); + }).start(); + // 3秒之后，生产一个包子 + Thread.sleep(3000L); + bunShop = new Object(); + synchronized (this) { + this.notifyAll(); + System.out.println("3、通知消费者"); + } + } + + /** + * 正常的park/unpark + */ + @Test + public void parkUnparkTest() throws Exception { + // 启动线程 + Thread consumerThread = new Thread(() -> { + // 如果没包子，则进入等待 + if (bunShop == null) { + System.out.println("1、进入等待"); + LockSupport.park(); + } + System.out.println("2、买到包子，回家"); + }); + consumerThread.start(); + // 3s后，生产一个包子 + Thread.sleep(3000L); + bunShop = new Object(); + LockSupport.unpark(consumerThread); + System.out.println("3、通知消费者"); + } + + /** + * 死锁的park/unpark + */ + @Test + public void parkUnparkDeadLockTest() throws Exception { + // 启动线程 + Thread consumerThread = new Thread(() -> { + if (bunShop == null) { // 如果没包子，则进入等待 + System.out.println("1、进入等待"); + // 当前线程拿到锁，然后挂起 + synchronized (this) { + LockSupport.park(); + } + } + System.out.println("2、买到包子，回家"); + }); + consumerThread.start(); + // 3秒之后，生产一个包子 + Thread.sleep(3000L); + bunShop = new Object(); + // 争取到锁以后，再恢复consumerThread + synchronized (this) { + LockSupport.unpark(consumerThread); + } + System.out.println("3、通知消费者"); + } + + public static void main(String[] args) throws Exception { + // 对调用顺序有要求，也要开发自己注意锁的释放。这个被弃用的API， 容易死锁，也容易导致永久挂起。 + // new Demo6().suspendResumeTest(); + // new Demo6().suspendResumeDeadLockTest(); + // new Demo6().suspendResumeDeadLockTest2(); + + // wait/notify要求再同步关键字里面使用，免去了死锁的困扰，但是一定要先调用wait，再调用notify，否则永久等待了 + // new Demo6().waitNotifyTest(); + // new Demo6().waitNotifyDeadLockTest(); + + // park/unpark没有顺序要求，但是park并不会释放锁，所有再同步代码中使用要注意 + // new Demo6().parkUnparkTest(); + // new Demo6().parkUnparkDeadLockTest(); + + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/state/ThreadState.java b/concurrency/src/main/java/com/javaedge/concurrency/common/state/ThreadState.java new file mode 100644 index 0000000..21ee75a --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/state/ThreadState.java @@ -0,0 +1,75 @@ +package com.javaedge.concurrency.common.state; + +/** + * 多线程运行状态切换 + * + * @author JavaEdge + * @date 2019/8/26 + */ +public class ThreadState { + public static Thread thread1; + public static ThreadState obj; + + public static void main(String[] args) throws Exception { + + // 第一种状态切换 - 新建 -> 运行 -> 终止 + System.out.println("======= 第一种状态切换 - 新建 -> 运行 -> 终止 ======="); + + Thread thread1 = new Thread(() -> { + System.out.println("thread1当前状态：" + Thread.currentThread().getState().toString()); + System.out.println("thread1 执行"); + }); + + System.out.println("未调用start方法，thread1当前状态：" + thread1.getState().toString()); + + thread1.start(); + + // 等待thread1执行结束，再看状态 + Thread.sleep(2000L); + System.out.println("等待2s，再看thread1当前状态：" + thread1.getState().toString()); + // thread1.start(); 线程终止之后，再调用start方法，会抛IllegalThreadStateException + + System.out.println("-------------------------------------"); + System.out.println("======= 第二种：新建 -> 运行 -> 等待 -> 运行 -> 终止(sleep方式) ======="); + Thread thread2 = new Thread(() -> { + try { + // 将线程2移动到等待状态，1500ms后自动唤醒 + Thread.sleep(1500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("thread2当前状态：" + Thread.currentThread().getState().toString()); + System.out.println("thread2 执行"); + }); + System.out.println("未调用start方法，thread2当前状态：" + thread2.getState().toString()); + thread2.start(); + System.out.println("调用start方法，thread2当前状态：" + thread2.getState().toString()); + // 等待200毫秒，再看状态 + Thread.sleep(200L); + System.out.println("等待200毫秒，再看thread2当前状态：" + thread2.getState().toString()); + // 再等待3秒，让thread2执行完毕，再看状态 + Thread.sleep(3000L); + System.out.println("等待3秒，再看thread2当前状态：" + thread2.getState().toString()); + + System.out.println("-------------------------------------"); + System.out.println("======= 第三种：新建 -> 运行 -> 阻塞 -> 运行 -> 终止 ======="); + Thread thread3 = new Thread(() -> { + synchronized (ThreadState.class) { + System.out.println("thread3当前状态：" + Thread.currentThread().getState().toString()); + System.out.println("thread3 执行了"); + } + }); + synchronized (ThreadState.class) { + System.out.println("未调用start方法，thread3当前状态：" + thread3.getState().toString()); + thread3.start(); + System.out.println("调用start方法，thread3当前状态：" + thread3.getState().toString()); + // 等待200毫秒，再看状态 + Thread.sleep(200L); + System.out.println("等待200毫秒，再看thread3当前状态：" + thread3.getState().toString()); + } + // 再等待3秒，让thread3执行完毕，再看状态 + Thread.sleep(3000L); + System.out.println("等待3秒，让thread3抢到锁，再看thread3当前状态：" + thread2.getState().toString()); + + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/stop/FlagStopThread.java b/concurrency/src/main/java/com/javaedge/concurrency/common/stop/FlagStopThread.java new file mode 100644 index 0000000..65dd10d --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/stop/FlagStopThread.java @@ -0,0 +1,30 @@ +package com.javaedge.concurrency.common.stop; + +/** + * 通过状态位来判断 + * + * @author JavaEdge + * @date 2019/8/29 + */ +public class FlagStopThread extends Thread { + + public volatile static boolean flag = true; + + public static void main(String[] args) throws InterruptedException { + new Thread(() -> { + try { + while (flag) { // 判断是否运行 + System.out.println("运行中"); + Thread.sleep(1000L); + } + } catch (InterruptedException e) { + e.printStackTrace(); + } + }).start(); + // 3s后，将状态标志改为False，代表不继续运行 + Thread.sleep(3000L); + flag = false; + System.out.println("程序运行结束"); + } +} + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/stop/PrimeGenerator.java b/concurrency/src/main/java/com/javaedge/concurrency/common/stop/PrimeGenerator.java new file mode 100644 index 0000000..627bb83 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/stop/PrimeGenerator.java @@ -0,0 +1,70 @@ +package com.javaedge.concurrency.common.stop; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import javax.annotation.concurrent.GuardedBy; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +import static java.util.concurrent.TimeUnit.SECONDS; + +/** + * @author JavaEdge + * @date 2021/5/8 + */ +@ThreadSafe +@Slf4j +public class PrimeGenerator implements Runnable { + private static ExecutorService exec = Executors.newCachedThreadPool(); + + @GuardedBy("this") + private final List primes = new ArrayList<>(); + private volatile boolean cancelled; + + @Override + public void run() { + BigInteger p = BigInteger.ONE; + // 主循环在搜索下一个素数之前会首先检查取消标志 + while (!cancelled) { + // 持续枚举素数，直到被取消 + p = p.nextProbablePrime(); + synchronized (this) { + primes.add(p); + } + } + } + + public void cancel() { + cancelled = true; + } + + public synchronized List get() { + return new ArrayList<>(primes); + } + + static List aSecondOfPrimes() throws InterruptedException { + PrimeGenerator generator = new PrimeGenerator(); + exec.execute(generator); + try { + + /** + * 素数生成器通常并不会刚好在运行 1s 后停止，因为在 请求取消的时刻 和 run方法中循环执行下一次检查 之间可能存在延迟 + */ + SECONDS.sleep(1); + } finally { + // cancel方法由finally块调用，从而确保即使在调用sleep时被中断，也能取消素数生成器的执行 + // 如果cancel没有被调用，那么搜索素数的线程将永远运行下去，不断消耗CPU时钟周期，且使得JVM不能正常退出 + generator.cancel(); + } + return generator.get(); + } + + public static void main(String[] args) throws InterruptedException { + log.info("result:{}", aSecondOfPrimes()); + } +} + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/stop/StopThread.java b/concurrency/src/main/java/com/javaedge/concurrency/common/stop/StopThread.java new file mode 100755 index 0000000..06e76d9 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/stop/StopThread.java @@ -0,0 +1,28 @@ +package com.javaedge.concurrency.common.stop; + +/** + * @author JavaEdge + * @date 2019/8/26 + */ +public class StopThread extends Thread { + private int i = 0, j = 0; + + @Override + public void run() { + synchronized (this) { + // 增加同步锁，确保线程安全 + ++i; + try { + // 休眠10s,模拟耗时操作 + Thread.sleep(10000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + ++j; + } + } + + public void print() { + System.out.println("i=" + i + " j=" + j); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/stop/ThreadStop.java b/concurrency/src/main/java/com/javaedge/concurrency/common/stop/ThreadStop.java new file mode 100644 index 0000000..d4fb9a9 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/stop/ThreadStop.java @@ -0,0 +1,26 @@ +package com.javaedge.concurrency.common.stop; + +/** + * @author JavaEdge + * @date 2019/8/26 + */ +public class ThreadStop { + public static void main(String[] args) throws InterruptedException { + StopThread thread = new StopThread(); + thread.start(); + // 休眠1秒，确保i变量自增成功 + Thread.sleep(1000); + // 错误的终止 线程stop强制性中止，破坏线程安全 +// thread.stop(); + + // 正确的终止 + thread.interrupt(); + while (thread.isAlive()) { + // 确保线程已经终止 + } // 输出结果 + thread.print(); + } +} + + + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo.java b/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo.java new file mode 100644 index 0000000..085d1d8 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo.java @@ -0,0 +1,55 @@ +package com.javaedge.concurrency.common.volatiletest; + +/** + * @author JavaEdge + * @date 2019/10/17 + */ +import java.util.concurrent.TimeUnit; + +// 1、 jre/bin/server 放置hsdis动态链接库 +// 测试代码 将运行模式设置为-server， 变成死循环 。 没加默认就是client模式，就是正常（可见性问题） +// 2、 通过设置JVM的参数，打印出jit编译的内容 （这里说的编译非class文件），通过可视化工具jitwatch进行查看 +// -server -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -XX:+LogCompilation -XX:LogFile=jit.log +// 关闭jit优化-Djava.compiler=NONE + +public class VisibilityDemo { + + /** + * 运行标志 + */ + public boolean flag = true; + + /** + * JIT just in time + * @param args + * @throws InterruptedException + */ + public static void main(String[] args) throws InterruptedException { + VisibilityDemo demo1 = new VisibilityDemo(); + System.out.println("代码开始了"); + Thread thread1 = new Thread(new Runnable() { + @Override + public void run() { + int i = 0; +// boolean f = demo1.flag; 不加valo是的jvm优化 +// if(f) { +// while(true){ +// i++; +// } +// } + while (demo1.flag) { + synchronized (this) { + i++; + } + } + System.out.println(i); + } + }); + thread1.start(); + + TimeUnit.SECONDS.sleep(2); + // 设置is为false，使上面的线程结束while循环 + demo1.flag = false; + System.out.println("被置为false了."); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo1.java b/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo1.java new file mode 100755 index 0000000..19169ba --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo1.java @@ -0,0 +1,39 @@ +package com.javaedge.concurrency.common.volatiletest; + +import java.util.concurrent.TimeUnit; + +/** + * @author JavaEdge + * @date 2019/10/17 + */ +public class VisibilityDemo1 { + + /** + * 状态标识 + */ + private static boolean is = true; + + public static void main(String[] args) { + new Thread(new Runnable() { + @Override + public void run() { + int i = 0; + while (VisibilityDemo1.is) { + synchronized (this) { + i++; + } + } + System.out.println(i); + } + }).start(); + + try { + TimeUnit.SECONDS.sleep(2); + } catch (InterruptedException e) { + e.printStackTrace(); + } + // 设置is为false，使上面的线程结束while循环 + VisibilityDemo1.is = false; + System.out.println("被置为false了."); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo2.java b/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo2.java new file mode 100755 index 0000000..edf43d4 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/common/volatiletest/VisibilityDemo2.java @@ -0,0 +1,42 @@ +package com.javaedge.concurrency.common.volatiletest; + +import java.util.concurrent.TimeUnit; + +/** + * @author JavaEdge + * @date 2019/10/17 + */ +public class VisibilityDemo2 { + + /** + * 状态标识 (不用缓存) + */ + private volatile boolean flag = true; + + // 源码 -> 字节码class + + /** + * JVM 转化为 操作系统能够执行的代码 （JIT Just In Time Compiler 编译器 ）（JVM -- client ， --server） + * + * @param args + * @throws InterruptedException + */ + public static void main(String[] args) throws InterruptedException { + VisibilityDemo2 demo1 = new VisibilityDemo2(); + new Thread(new Runnable() { + @Override + public void run() { + int i = 0; + while (demo1.flag) { + i++; + } + System.out.println(i); + } + }).start(); + + TimeUnit.SECONDS.sleep(2); + // 设置is为false，使上面的线程结束while循环 + demo1.flag = false; + System.out.println("被置为false了."); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/LockSupportBlockerTest.java b/concurrency/src/main/java/com/javaedge/concurrency/example/LockSupportBlockerTest.java new file mode 100644 index 0000000..ed5b786 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/LockSupportBlockerTest.java @@ -0,0 +1,30 @@ +package com.javaedge.concurrency.example; + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.LockSupport; + +public class LockSupportBlockerTest { + public static void main(String[] args) { + Thread t3 = new Thread(() -> { + Thread.currentThread().setName("t3"); + System.out.println(Thread.currentThread().getName() + " park 5 seconds"); + //park 5 seconds, set blocker + Object blocker = new String("JavaEdge"); + LockSupport.parkUntil(blocker, System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(5, TimeUnit.SECONDS)); + System.out.println(Thread.currentThread().getName() + " after park"); + }); + t3.start(); + + try { + Object t3_blocker = null; + while (t3_blocker == null) { + t3_blocker = LockSupport.getBlocker(t3); + TimeUnit.MILLISECONDS.sleep(10); + } + System.out.println("t3 blocker is :" + t3_blocker); + t3.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/LockSupportTest.java b/concurrency/src/main/java/com/javaedge/concurrency/example/LockSupportTest.java new file mode 100644 index 0000000..624b1cb --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/LockSupportTest.java @@ -0,0 +1,56 @@ +package com.javaedge.concurrency.example; + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.LockSupport; + +/** + * @author JavaEdge + */ +public class LockSupportTest { + public static void main(String[] args) { + Thread t1 = new Thread() { + @Override + public void run() { + Thread.currentThread().setName("t1"); + System.out.println(Thread.currentThread().getName() + " before park"); + //park 100 seconds + LockSupport.parkNanos(TimeUnit.NANOSECONDS.convert(100, TimeUnit.SECONDS)); + System.out.println(Thread.currentThread().getName() + " after park"); + } + }; + Thread t2 = new Thread() { + @Override + public void run() { + try { + Thread.currentThread().setName("t2"); + TimeUnit.SECONDS.sleep(1); + System.out.println(Thread.currentThread().getName() + " unpark t1"); + LockSupport.unpark(t1); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + } + }; + Thread t3 = new Thread() { + @Override + public void run() { + Thread.currentThread().setName("t3"); + System.out.println(Thread.currentThread().getName() + " park 5 seconds"); + //park 5 seconds + LockSupport.parkUntil(System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(5,TimeUnit.SECONDS)); + System.out.println(Thread.currentThread().getName() + " after park"); + } + }; + t1.start(); + t2.start(); + t3.start(); + try { + t1.join(); + t2.join(); + t3.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/UnsafeTest.java b/concurrency/src/main/java/com/javaedge/concurrency/example/UnsafeTest.java new file mode 100644 index 0000000..e24004c --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/UnsafeTest.java @@ -0,0 +1,59 @@ +package com.javaedge.concurrency.example; + +import sun.misc.Unsafe; + +import java.lang.reflect.Field; +import java.util.concurrent.TimeUnit; + +public class UnsafeTest { + + public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { + Field f = Unsafe.class.getDeclaredField("theUnsafe"); + f.setAccessible(true); + Unsafe unsafe = (Unsafe) f.get(null); + Thread t1 = new Thread() { + @Override + public void run() { + Thread.currentThread().setName("t1"); + System.out.println(Thread.currentThread().getName() + " before park"); + //park 100 seconds + unsafe.park(false, TimeUnit.NANOSECONDS.convert(100, TimeUnit.SECONDS)); + System.out.println(Thread.currentThread().getName() + " after park"); + } + }; + Thread t2 = new Thread() { + @Override + public void run() { + try { + Thread.currentThread().setName("t2"); + TimeUnit.SECONDS.sleep(1); + System.out.println(Thread.currentThread().getName() + " unpark t1"); + unsafe.unpark(t1); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + } + }; + Thread t3 = new Thread() { + @Override + public void run() { + Thread.currentThread().setName("t3"); + System.out.println(Thread.currentThread().getName() + " park 5 seconds"); + //park 5 seconds + unsafe.park(true, System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(5,TimeUnit.SECONDS)); + System.out.println(Thread.currentThread().getName() + " after park"); + } + }; + t1.start(); + t2.start(); + t3.start(); + try { + t1.join(); + t2.join(); + t3.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CountDownLatchExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CountDownLatchExample1.java new file mode 100755 index 0000000..ce28dda --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CountDownLatchExample1.java @@ -0,0 +1,42 @@ +package com.javaedge.concurrency.example.aqs; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +@Slf4j +public class CountDownLatchExample1 { + + private final static int threadCount = 200; + + public static void main(String[] args) throws Exception { + + ExecutorService exec = Executors.newCachedThreadPool(); + + final CountDownLatch countDownLatch = new CountDownLatch(threadCount); + + for (int i = 0; i < threadCount; i++) { + final int threadNum = i; + exec.execute(() -> { + try { + test(threadNum); + } catch (Exception e) { + log.error("exception", e); + } finally { + countDownLatch.countDown(); + } + }); + } + countDownLatch.await(); + log.info("finish"); + exec.shutdown(); + } + + private static void test(int threadNum) throws Exception { + Thread.sleep(100); + log.info("{}", threadNum); + Thread.sleep(100); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CountDownLatchExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CountDownLatchExample2.java new file mode 100755 index 0000000..65dacf0 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CountDownLatchExample2.java @@ -0,0 +1,42 @@ +package com.javaedge.concurrency.example.aqs; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; + +@Slf4j +public class CountDownLatchExample2 { + + private final static int threadCount = 200; + + public static void main(String[] args) throws Exception { + + ExecutorService exec = Executors.newCachedThreadPool(); + + final CountDownLatch countDownLatch = new CountDownLatch(threadCount); + + for (int i = 0; i < threadCount; i++) { + final int threadNum = i; + exec.execute(() -> { + try { + test(threadNum); + } catch (Exception e) { + log.error("exception", e); + } finally { + countDownLatch.countDown(); + } + }); + } + countDownLatch.await(10, TimeUnit.MILLISECONDS); + log.info("finish"); + exec.shutdown(); + } + + private static void test(int threadNum) throws Exception { + Thread.sleep(100); + log.info("{}", threadNum); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample1.java new file mode 100755 index 0000000..f117926 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample1.java @@ -0,0 +1,38 @@ +package com.javaedge.concurrency.example.aqs; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CyclicBarrier; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +@Slf4j +public class CyclicBarrierExample1 { + + private static CyclicBarrier barrier = new CyclicBarrier(5); + + public static void main(String[] args) throws Exception { + + ExecutorService executor = Executors.newCachedThreadPool(); + + for (int i = 0; i < 10; i++) { + final int threadNum = i; + Thread.sleep(1000); + executor.execute(() -> { + try { + race(threadNum); + } catch (Exception e) { + log.error("exception", e); + } + }); + } + executor.shutdown(); + } + + private static void race(int threadNum) throws Exception { + Thread.sleep(1000); + log.info("{} is ready", threadNum); + barrier.await(); + log.info("{} continue", threadNum); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample2.java new file mode 100755 index 0000000..19024d8 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample2.java @@ -0,0 +1,43 @@ +package com.javaedge.concurrency.example.aqs; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CyclicBarrier; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; + +@Slf4j +public class CyclicBarrierExample2 { + + private static CyclicBarrier barrier = new CyclicBarrier(5); + + public static void main(String[] args) throws Exception { + + ExecutorService executor = Executors.newCachedThreadPool(); + + for (int i = 0; i < 10; i++) { + final int threadNum = i; + Thread.sleep(1000); + executor.execute(() -> { + try { + race(threadNum); + } catch (Exception e) { + log.error("exception", e); + } + }); + } + executor.shutdown(); + } + + private static void race(int threadNum) throws Exception { + Thread.sleep(1000); + log.info("{} is ready", threadNum); + try { + barrier.await(2000, TimeUnit.MILLISECONDS); + } catch (Exception e) { + log.warn("BarrierException", e); + } + log.info("{} continue", threadNum); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample3.java new file mode 100755 index 0000000..90663bc --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/CyclicBarrierExample3.java @@ -0,0 +1,40 @@ +package com.javaedge.concurrency.example.aqs; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CyclicBarrier; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +@Slf4j +public class CyclicBarrierExample3 { + + private static CyclicBarrier barrier = new CyclicBarrier(5, () -> { + log.info("callback is running"); + }); + + public static void main(String[] args) throws Exception { + + ExecutorService executor = Executors.newCachedThreadPool(); + + for (int i = 0; i < 10; i++) { + final int threadNum = i; + Thread.sleep(1000); + executor.execute(() -> { + try { + race(threadNum); + } catch (Exception e) { + log.error("exception", e); + } + }); + } + executor.shutdown(); + } + + private static void race(int threadNum) throws Exception { + Thread.sleep(1000); + log.info("{} is ready", threadNum); + barrier.await(); + log.info("{} continue", threadNum); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/SampleLock.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/SampleLock.java new file mode 100644 index 0000000..4ebff9e --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/SampleLock.java @@ -0,0 +1,25 @@ +package com.javaedge.concurrency.example.aqs; + +/** + * @author JavaEdge + * @date 2021/4/21 + */ +class SampleLock { + volatile int state; + + /** + * 加锁 + */ + void lock() { + // ... + state = 1; + } + + /** + * 解锁 + */ + void unlock() { + // ... + state = 0; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/SimpleLock.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/SimpleLock.java new file mode 100644 index 0000000..780332b --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/SimpleLock.java @@ -0,0 +1,75 @@ +package com.javaedge.concurrency.example.aqs; + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.AbstractQueuedSynchronizer; + +public class SimpleLock { + private static class Sync extends AbstractQueuedSynchronizer { + @Override + protected boolean tryAcquire(int ignore) { + return compareAndSetState(0, 1); + } + + @Override + protected boolean tryRelease(int ignore) { + setState(0); + return true; + } + + protected Sync() { + super(); + } + } + + private final Sync sync = new Sync(); + + public void lock() { + sync.acquire(1); + } + + public void unlock() { + sync.release(1); + } + + private static class MyThread extends Thread { + private final String name; + private final SimpleLock lock; + + private MyThread(String name, SimpleLock lock) { + this.name = name; + this.lock = lock; + } + + @Override + public void run() { + try { + lock.lock(); + System.out.println(name + " get the lock"); + TimeUnit.SECONDS.sleep(2); + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + lock.unlock(); + System.out.println(name + " release the lock"); + } + } + } + + public static void main(String[] args) { + final SimpleLock mutex = new SimpleLock(); + MyThread t1 = new MyThread("t1", mutex); + MyThread t2 = new MyThread("t2", mutex); + MyThread t3 = new MyThread("t3", mutex); + t1.start(); + t2.start(); + t3.start(); + try { + t1.join(); + t2.join(); + t3.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("main thread exit!"); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/MicrowaveOvenPool.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/MicrowaveOvenPool.java new file mode 100644 index 0000000..10c7c4a --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/MicrowaveOvenPool.java @@ -0,0 +1,87 @@ +package com.javaedge.concurrency.example.aqs.semaphore; + +import javax.validation.constraints.NotNull; +import java.util.List; +import java.util.Vector; +import java.util.concurrent.Semaphore; +import java.util.function.Function; + +/** + * @author JavaEdge + * @date 2021/4/22 + */ +class Food { + + public String name; + + private long warmTime; + + public Food(String name, long warmTime) { + this.name = name; + this.warmTime = warmTime; + } + + public String getName() { + return name; + } + + public long getWarmTime() { + return warmTime; + } +} + +class MicrowaveOven { + + public String name; + + public MicrowaveOven(String name) { + this.name = name; + } + + public Food warm(Food food) { + long second = food.getWarmTime() * 1000; + try { + Thread.sleep(second); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + System.out.println(String.format("%s warm %s %d seconds food.", name, food.getName(), food.getWarmTime())); + return food; + } + + public String getName() { + return name; + } +} + +/** + * @author JavaEdge + */ +public class MicrowaveOvenPool { + + private List microwaveOvens; + + private Semaphore semaphore; + + public MicrowaveOvenPool(int size, @NotNull List microwaveOvens) { + this.microwaveOvens = new Vector<>(microwaveOvens); + this.semaphore = new Semaphore(size); + } + + public Food exec(Function func) { + MicrowaveOven microwaveOven = null; + try { + semaphore.acquire(); + microwaveOven = microwaveOvens.remove(0); + return func.apply(microwaveOven); + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + microwaveOvens.add(microwaveOven); + semaphore.release(); + } + return null; + } + +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/ObjPool.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/ObjPool.java new file mode 100644 index 0000000..4940086 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/ObjPool.java @@ -0,0 +1,71 @@ +package com.javaedge.concurrency.example.aqs.semaphore; + +import lombok.extern.slf4j.Slf4j; + +import java.util.List; +import java.util.Vector; +import java.util.concurrent.Semaphore; +import java.util.function.Function; + +/** + * @author JavaEdge + * @date 2021/4/22 + */ +@Slf4j +public class ObjPool { + + final List pool; + + /** + * 用信号量实现限流器 + */ + final Semaphore sem; + + ObjPool(int size, T t) { + // 使用线程安全的vector,因为信号量支持多个线程进入临界区 + // 执行 add、remove 方法时可能有并发 + pool = new Vector() {}; + for (int i = 0; i < size; i++) { + pool.add(t); + } + sem = new Semaphore(size); + } + + /** + * 利用对象池的对象，调用func + */ + R exec(Function func) throws InterruptedException { + T t = null; + // 前10个线程调用acquire()方法，都能继续执行，相当于通过了信号灯 + // 而其他线程则会阻塞在acquire() + sem.acquire(); + try { + // 通过信号灯的线程，为每个线程分配一个对象 t + t = pool.remove(0); + // 执行回调方法 + R apply = func.apply(t); + return apply; + } finally { + // 执行完回调后，释放对象 + pool.add(t); + + /** + * 更新信号量的计数器 + * 如果此时信号量里计数器的值≤0，说明有线程在等待 + * 此时会自动唤醒等待的线程 + */ + sem.release(); + } + } + + public static void main(String[] args) throws InterruptedException { + // 创建对象池 + ObjPool pool = new ObjPool<>(10, 2L); + // 通过对象池获取t，之后执行 + pool.exec(t -> { + log.info("t:{}", t); + return t.toString(); + }); + } +} + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample1.java new file mode 100755 index 0000000..9dc977c --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample1.java @@ -0,0 +1,42 @@ +package com.javaedge.concurrency.example.aqs.semaphore; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +/** + * @author JavaEdge + */ +@Slf4j +public class SemaphoreExample1 { + + private final static int THREAD_COUNT = 20; + + public static void main(String[] args) throws Exception { + + ExecutorService exec = Executors.newCachedThreadPool(); + + final Semaphore semaphore = new Semaphore(3); + + for (int i = 0; i < THREAD_COUNT; i++) { + final int threadNum = i; + exec.execute(() -> { + try { + semaphore.acquire(); // 获取一个许可 + test(threadNum); + semaphore.release(); // 释放一个许可 + } catch (Exception e) { + log.error("exception", e); + } + }); + } + exec.shutdown(); + } + + private static void test(int threadNum) throws Exception { + log.info("{}", threadNum); + Thread.sleep(1000); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample2.java new file mode 100755 index 0000000..e6a99fe --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample2.java @@ -0,0 +1,39 @@ +package com.javaedge.concurrency.example.aqs.semaphore; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +public class SemaphoreExample2 { + + private final static int threadCount = 20; + + public static void main(String[] args) throws Exception { + + ExecutorService exec = Executors.newCachedThreadPool(); + + final Semaphore semaphore = new Semaphore(3); + + for (int i = 0; i < threadCount; i++) { + final int threadNum = i; + exec.execute(() -> { + try { + semaphore.acquire(3); // 获取多个许可 + test(threadNum); + semaphore.release(3); // 释放多个许可 + } catch (Exception e) { + log.error("exception", e); + } + }); + } + exec.shutdown(); + } + + private static void test(int threadNum) throws Exception { + log.info("{}", threadNum); + Thread.sleep(1000); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample3.java new file mode 100755 index 0000000..764d0c6 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample3.java @@ -0,0 +1,41 @@ +package com.javaedge.concurrency.example.aqs.semaphore; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.TimeUnit; + +@Slf4j +public class SemaphoreExample3 { + + private final static int threadCount = 20; + + public static void main(String[] args) throws Exception { + + ExecutorService exec = Executors.newCachedThreadPool(); + + final Semaphore semaphore = new Semaphore(3); + + for (int i = 0; i < threadCount; i++) { + final int threadNum = i; + exec.execute(() -> { + try { + if (semaphore.tryAcquire()) { // 尝试获取一个许可 + test(threadNum); + semaphore.release(); // 释放一个许可 + } + } catch (Exception e) { + log.error("exception", e); + } + }); + } + exec.shutdown(); + } + + private static void test(int threadNum) throws Exception { + log.info("{}", threadNum); + Thread.sleep(1000); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample4.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample4.java new file mode 100755 index 0000000..d82bdba --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample4.java @@ -0,0 +1,41 @@ +package com.javaedge.concurrency.example.aqs.semaphore; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.TimeUnit; + +@Slf4j +public class SemaphoreExample4 { + + private final static int threadCount = 20; + + public static void main(String[] args) throws Exception { + + ExecutorService exec = Executors.newCachedThreadPool(); + + final Semaphore semaphore = new Semaphore(3); + + for (int i = 0; i < threadCount; i++) { + final int threadNum = i; + exec.execute(() -> { + try { + if (semaphore.tryAcquire(5000, TimeUnit.MILLISECONDS)) { // 尝试获取一个许可 + test(threadNum); + semaphore.release(); // 释放一个许可 + } + } catch (Exception e) { + log.error("exception", e); + } + }); + } + exec.shutdown(); + } + + private static void test(int threadNum) throws Exception { + log.info("{}", threadNum); + Thread.sleep(1000); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample5.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample5.java new file mode 100755 index 0000000..f765064 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample5.java @@ -0,0 +1,53 @@ +package com.javaedge.concurrency.example.aqs.semaphore; + +import lombok.extern.slf4j.Slf4j; + +import java.util.Queue; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.TimeUnit; + +/** + * @author JavaEdge + */ +@Slf4j +public class SemaphoreExample5 { + /** + * 计数器 + */ + int count; + + /** + * 等待队列 + */ + Queue queue; + + /** + * 初始化 + * + * @param c + */ + void Semaphore(int c){ + this.count=c; + } + + void down(){ + this.count--; + if(this.count<0){ + // 将当前线程插入等待队列 + // 阻塞当前线程 + } + } + void up(){ + this.count++; + if(this.count<=0) { + // 移除等待队列中的某个线程t + // 唤醒线程t + } + } + + public static void main(String[] args) { + + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample6.java b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample6.java new file mode 100755 index 0000000..a6f9587 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/aqs/semaphore/SemaphoreExample6.java @@ -0,0 +1,34 @@ +package com.javaedge.concurrency.example.aqs.semaphore; + +import java.util.concurrent.Semaphore; + +/** + * @author JavaEdge + */ +public class SemaphoreExample6 { + + static int count; + + /** + * 初始化信号量 + */ + static final Semaphore SEMAPHORE = new Semaphore(1); + + /** + * 信号量保证互斥 + */ + static void add() throws InterruptedException { + // 进入临界区之前执行 + SEMAPHORE.acquire(); + try { + count += 1; + } finally { + // 退出临界区之前执行 + SEMAPHORE.release(); + } + } + + public static void main(String[] args) throws InterruptedException { + add(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample1.java new file mode 100755 index 0000000..eaba128 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample1.java @@ -0,0 +1,49 @@ +package com.javaedge.concurrency.example.atomic; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.atomic.AtomicInteger; + +@Slf4j +@ThreadSafe +public class AtomicExample1 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static AtomicInteger count = new AtomicInteger(0); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count.get()); + } + + private static void add() { + count.incrementAndGet(); + // count.getAndIncrement(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample2.java new file mode 100755 index 0000000..452bfb4 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample2.java @@ -0,0 +1,49 @@ +package com.javaedge.concurrency.example.atomic; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.atomic.AtomicLong; + +@Slf4j +@ThreadSafe +public class AtomicExample2 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static AtomicLong count = new AtomicLong(0); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count.get()); + } + + private static void add() { + count.incrementAndGet(); + // count.getAndIncrement(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample3.java new file mode 100755 index 0000000..c6e20d3 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample3.java @@ -0,0 +1,48 @@ +package com.javaedge.concurrency.example.atomic; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.atomic.LongAdder; + +@Slf4j +@ThreadSafe +public class AtomicExample3 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static LongAdder count = new LongAdder(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count); + } + + private static void add() { + count.increment(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample4.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample4.java new file mode 100755 index 0000000..d2b3c25 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample4.java @@ -0,0 +1,22 @@ +package com.javaedge.concurrency.example.atomic; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.atomic.AtomicReference; + +@Slf4j +@ThreadSafe +public class AtomicExample4 { + + private static AtomicReference count = new AtomicReference<>(0); + + public static void main(String[] args) { + count.compareAndSet(0, 2); // 2 + count.compareAndSet(0, 1); // no + count.compareAndSet(1, 3); // no + count.compareAndSet(2, 4); // 4 + count.compareAndSet(3, 5); // no + log.info("count:{}", count.get()); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample5.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample5.java new file mode 100755 index 0000000..f4cc64c --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample5.java @@ -0,0 +1,33 @@ +package com.javaedge.concurrency.example.atomic; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.Getter; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.atomic.AtomicIntegerFieldUpdater; + +@Slf4j +@ThreadSafe +public class AtomicExample5 { + + private static AtomicIntegerFieldUpdater updater = + AtomicIntegerFieldUpdater.newUpdater(AtomicExample5.class, "count"); + + @Getter + public volatile int count = 100; + + public static void main(String[] args) { + + AtomicExample5 example5 = new AtomicExample5(); + + if (updater.compareAndSet(example5, 100, 120)) { + log.info("update success 1, {}", example5.getCount()); + } + + if (updater.compareAndSet(example5, 100, 120)) { + log.info("update success 2, {}", example5.getCount()); + } else { + log.info("update failed, {}", example5.getCount()); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample6.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample6.java new file mode 100755 index 0000000..7d37d40 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicExample6.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.atomic; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.atomic.AtomicBoolean; + +@Slf4j +@ThreadSafe +public class AtomicExample6 { + + private static AtomicBoolean isHappened = new AtomicBoolean(false); + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + test(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("isHappened:{}", isHappened.get()); + } + + private static void test() { + if (isHappened.compareAndSet(false, true)) { + log.info("execute"); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicTest.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicTest.java new file mode 100755 index 0000000..5293174 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/AtomicTest.java @@ -0,0 +1,26 @@ +package com.javaedge.concurrency.example.atomic; + +import java.util.concurrent.atomic.AtomicInteger; + +/** + * atomic 相关测试代码 + * + * @author JavaEdge + * @date 2019/10/20 + */ +public class AtomicTest { + + public static void main(String[] args) throws InterruptedException { + // 自增 + AtomicInteger atomicInteger = new AtomicInteger(0); + for (int i = 0; i < 2; i++) { + new Thread(() -> { + for (int j = 0; j < 10000; j++) { + atomicInteger.incrementAndGet(); + } + }).start(); + } + Thread.sleep(2000L); + System.out.println(atomicInteger.get()); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LockCASDemo.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LockCASDemo.java new file mode 100644 index 0000000..9c0e3d8 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LockCASDemo.java @@ -0,0 +1,72 @@ +package com.javaedge.concurrency.example.atomic; + +import sun.misc.Unsafe; + +import java.io.IOException; +import java.lang.reflect.Field; + +/** + * 两个线程，对 i 变量进行递增操作 + * + * @author JavaEdge + * @date 2019/10/18 + */ +public class LockCASDemo { + + volatile int i = 0; + + private static Unsafe unsafe; + + /** + * + * 属性偏移量，用于JVM去定位属性在内存中的地址 + */ + static long valueOffset; + + static { + try { + Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe"); + theUnsafe.setAccessible(true); + unsafe = (Unsafe) theUnsafe.get(null); + + // CAS 硬件原语 ---java语言 无法直接改内存。 曲线通过对象及属性的定位方式 + valueOffset = unsafe.objectFieldOffset(LockCASDemo.class.getDeclaredField("i")); + } catch (Exception e) { + e.printStackTrace(); + } + // unsafe = + } + + public void add() { // 方法栈帧~ 局部变量 + // 无锁编程 -- cas + 自旋锁 + // TODO xx00 + // i++; // 三次操作 + int current; + int value; + do { + current = unsafe.getIntVolatile(this, valueOffset); // 读取当前值 + value = current + 1; // 计算 + } while (!unsafe.compareAndSwapInt(this, valueOffset, current, value));// CAS 底层API + +// if(current == i) { +// i = value; // 赋值 +// } else { +// // 值发生变化，修改失败 +// } + } + + public static void main(String[] args) throws InterruptedException, IOException { + LockCASDemo ld = new LockCASDemo(); + + for (int i = 0; i < 2; i++) { // 2w相加，20000 + new Thread(() -> { + for (int j = 0; j < 10000; j++) { + ld.add(); + } + }).start(); + } + System.in.read(); // 输入任意键退出 + System.out.println(ld.i); + } +} + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LongAccumulatorDemo.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LongAccumulatorDemo.java new file mode 100755 index 0000000..dcdf135 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LongAccumulatorDemo.java @@ -0,0 +1,34 @@ +package com.javaedge.concurrency.example.atomic; + +import java.util.concurrent.atomic.LongAccumulator; +import java.util.function.LongBinaryOperator; + +/** + * LongAdder增强版，处理累加之外，可以自行定义其他计算 + * + * @author JavaEdge + * @date 2019/10/18 + */ +public class LongAccumulatorDemo { + public static void main(String[] args) throws InterruptedException { + LongAccumulator accumulator = new LongAccumulator(new LongBinaryOperator() { + @Override + public long applyAsLong(long left, long right) { + // 返回最大值，这就是自定义的计算 + return left < right ? left : right; + } + }, 0); + + // 1000个线程 + for (int i = 0; i < 1000; i++) { + int finalI = i; + new Thread(() -> { + accumulator.accumulate(finalI); // 此处实际就是执行上面定义的操作 + }).start(); + } + + Thread.sleep(2000L); + System.out.println(accumulator.longValue()); // 打印出结果 + } + +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LongAdderDemo.java b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LongAdderDemo.java new file mode 100755 index 0000000..16927b1 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/atomic/LongAdderDemo.java @@ -0,0 +1,73 @@ +package com.javaedge.concurrency.example.atomic; + +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.LongAdder; + +/** + * 测试用例： 同时运行2秒，检查谁的次数最多 + * + * @author JavaEdge + * @date 2019/10/18 + */ +public class LongAdderDemo { + private long count = 0; + + /** + * 同步代码块的方式 + * @throws InterruptedException + */ + public void testSync() throws InterruptedException { + for (int i = 0; i < 3; i++) { + new Thread(() -> { + long starttime = System.currentTimeMillis(); + while (System.currentTimeMillis() - starttime < 2000) { // 运行两秒 + synchronized (this) { + ++count; + } + } + long endtime = System.currentTimeMillis(); + System.out.println("SyncThread spend:" + (endtime - starttime) + "ms" + " v" + count); + }).start(); + } + } + + /** + * Atomic方式 + */ + private AtomicLong acount = new AtomicLong(0L); + + public void testAtomic() throws InterruptedException { + for (int i = 0; i < 3; i++) { + new Thread(() -> { + long starttime = System.currentTimeMillis(); + while (System.currentTimeMillis() - starttime < 2000) { // 运行两秒 + acount.incrementAndGet(); // acount++; + } + long endtime = System.currentTimeMillis(); + System.out.println("AtomicThread spend:" + (endtime - starttime) + "ms" + " v-" + acount.incrementAndGet()); + }).start(); + } + } + + // LongAdder 方式 + private LongAdder lacount = new LongAdder(); + public void testLongAdder() throws InterruptedException { + for (int i = 0; i < 3; i++) { + new Thread(() -> { + long starttime = System.currentTimeMillis(); + while (System.currentTimeMillis() - starttime < 2000) { // 运行两秒 + lacount.increment(); + } + long endtime = System.currentTimeMillis(); + System.out.println("LongAdderThread spend:" + (endtime - starttime) + "ms" + " v-" + lacount.sum()); + }).start(); + } + } + + public static void main(String[] args) throws InterruptedException { + LongAdderDemo demo = new LongAdderDemo(); + demo.testSync(); + demo.testAtomic(); + demo.testLongAdder(); + } +} \ No newline at end of file diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/cache/CacheController.java b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/CacheController.java new file mode 100755 index 0000000..1eb5898 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/CacheController.java @@ -0,0 +1,32 @@ +package com.javaedge.concurrency.example.cache; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.ResponseBody; + +/** + * @author JavaEdge + */ +@Controller +@RequestMapping("/cache") +public class CacheController { + + @Autowired + private RedisClient redisClient; + + @RequestMapping("/set") + @ResponseBody + public String set(@RequestParam("k") String k, @RequestParam("v") String v) + throws Exception { + redisClient.set(k, v); + return "SUCCESS"; + } + + @RequestMapping("/get") + @ResponseBody + public String get(@RequestParam("k") String k) throws Exception { + return redisClient.get(k); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/cache/GuavaCacheExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/GuavaCacheExample1.java new file mode 100755 index 0000000..e66ca99 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/GuavaCacheExample1.java @@ -0,0 +1,57 @@ +package com.javaedge.concurrency.example.cache; + +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.TimeUnit; + +@Slf4j +public class GuavaCacheExample1 { + + public static void main(String[] args) { + + LoadingCache cache = CacheBuilder.newBuilder() + .maximumSize(10) // 最多存放10个数据 + .expireAfterWrite(10, TimeUnit.SECONDS) // 缓存10秒 + .recordStats() // 开启记录状态数据功能 + .build(new CacheLoader() { + @Override + public Integer load(String key) throws Exception { + return -1; + } + }); + + log.info("{}", cache.getIfPresent("key1")); // null + cache.put("key1", 1); + log.info("{}", cache.getIfPresent("key1")); // 1 + cache.invalidate("key1"); + log.info("{}", cache.getIfPresent("key1")); // null + + try { + log.info("{}", cache.get("key2")); // -1 + cache.put("key2", 2); + log.info("{}", cache.get("key2")); // 2 + + log.info("{}", cache.size()); // 1 + + for (int i = 3; i < 13; i++) { + cache.put("key" + i, i); + } + log.info("{}", cache.size()); // 10 + + log.info("{}", cache.getIfPresent("key2")); // null + + Thread.sleep(11000); + + log.info("{}", cache.get("key5")); // -1 + + log.info("{},{}", cache.stats().hitCount(), cache.stats().missCount()); + + log.info("{},{}", cache.stats().hitRate(), cache.stats().missRate()); + } catch (Exception e) { + log.error("cache exception", e); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/cache/GuavaCacheExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/GuavaCacheExample2.java new file mode 100755 index 0000000..9c192ab --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/GuavaCacheExample2.java @@ -0,0 +1,67 @@ +package com.javaedge.concurrency.example.cache; + +import com.google.common.cache.Cache; +import com.google.common.cache.CacheBuilder; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.Callable; +import java.util.concurrent.TimeUnit; + +@Slf4j +public class GuavaCacheExample2 { + + public static void main(String[] args) { + + Cache cache = CacheBuilder.newBuilder() + .maximumSize(10) // 最多存放10个数据 + .expireAfterWrite(10, TimeUnit.SECONDS) // 缓存10秒 + .recordStats() // 开启记录状态数据功能 + .build(); + + log.info("{}", cache.getIfPresent("key1")); // null + cache.put("key1", 1); + log.info("{}", cache.getIfPresent("key1")); // 1 + cache.invalidate("key1"); + log.info("{}", cache.getIfPresent("key1")); // null + + try { + log.info("{}", cache.get("key2", new Callable() { + @Override + public Integer call() throws Exception { + return -1; + } + })); // -1 + cache.put("key2", 2); + log.info("{}", cache.get("key2", new Callable() { + @Override + public Integer call() throws Exception { + return -1; + } + })); // 2 + + log.info("{}", cache.size()); // 1 + + for (int i = 3; i < 13; i++) { + cache.put("key" + i, i); + } + log.info("{}", cache.size()); // 10 + + log.info("{}", cache.getIfPresent("key2")); // null + + Thread.sleep(11000); + + log.info("{}", cache.get("key5", new Callable() { + @Override + public Integer call() throws Exception { + return -1; + } + })); // -1 + + log.info("{},{}", cache.stats().hitCount(), cache.stats().missCount()); + + log.info("{},{}", cache.stats().hitRate(), cache.stats().missRate()); + } catch (Exception e) { + log.error("cache exception", e); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/cache/RedisClient.java b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/RedisClient.java new file mode 100755 index 0000000..cf12169 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/RedisClient.java @@ -0,0 +1,42 @@ +package com.javaedge.concurrency.example.cache; + +import org.springframework.stereotype.Component; +import redis.clients.jedis.Jedis; +import redis.clients.jedis.JedisPool; + +import javax.annotation.Resource; + +/** + * @author JavaEdge + */ +@Component +public class RedisClient { + + @Resource(name = "redisPool") + private JedisPool jedisPool; + + public void set(String key, String value) throws Exception { + Jedis jedis = null; + try { + jedis = jedisPool.getResource(); + jedis.set(key, value); + } finally { + if (jedis != null) { + jedis.close(); + } + } + } + + public String get(String key) throws Exception { + Jedis jedis = null; + try { + jedis = jedisPool.getResource(); + return jedis.get(key); + } finally { + if (jedis != null) { + jedis.close(); + } + } + } +} + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/cache/RedisConfig.java b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/RedisConfig.java new file mode 100755 index 0000000..1100ff7 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/cache/RedisConfig.java @@ -0,0 +1,19 @@ +package com.javaedge.concurrency.example.cache; + +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import redis.clients.jedis.JedisPool; + +/** + * @author JavaEdge + */ +@Configuration +public class RedisConfig { + + @Bean(name = "redisPool") + public JedisPool jedisPool(@Value("${jedis.host}") String host, + @Value("${jedis.port}") int port) { + return new JedisPool(host, port); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/ArrayListExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/ArrayListExample.java new file mode 100755 index 0000000..e380611 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/ArrayListExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.commonunsafe; + +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@NotThreadSafe +public class ArrayListExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static List list = new ArrayList<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", list.size()); + } + + private static void update(int i) { + list.add(i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample1.java new file mode 100755 index 0000000..abead7a --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample1.java @@ -0,0 +1,51 @@ +package com.javaedge.concurrency.example.commonunsafe; + +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.text.SimpleDateFormat; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@NotThreadSafe +public class DateFormatExample1 { + + private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd"); + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + update(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + } + + private static void update() { + try { + simpleDateFormat.parse("20180208"); + } catch (Exception e) { + log.error("parse exception", e); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample2.java new file mode 100755 index 0000000..9be2cf6 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample2.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.commonunsafe; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.text.SimpleDateFormat; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class DateFormatExample2 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + update(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + } + + private static void update() { + try { + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd"); + simpleDateFormat.parse("20180208"); + } catch (Exception e) { + log.error("parse exception", e); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample3.java new file mode 100755 index 0000000..133a7ca --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/DateFormatExample3.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.commonunsafe; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; +import org.joda.time.DateTime; +import org.joda.time.format.DateTimeFormat; +import org.joda.time.format.DateTimeFormatter; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class DateFormatExample3 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyyMMdd"); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + } + + private static void update(int i) { + log.info("{}, {}", i, DateTime.parse("20180208", dateTimeFormatter).toDate()); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/HashMapExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/HashMapExample.java new file mode 100755 index 0000000..769a7b6 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/HashMapExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.commonunsafe; + +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@NotThreadSafe +public class HashMapExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Map map = new HashMap<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", map.size()); + } + + private static void update(int i) { + map.put(i, i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/HashSetExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/HashSetExample.java new file mode 100755 index 0000000..d7f01e8 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/HashSetExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.commonunsafe; + +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@NotThreadSafe +public class HashSetExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Set set = new HashSet<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", set.size()); + } + + private static void update(int i) { + set.add(i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/StringExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/StringExample1.java new file mode 100755 index 0000000..8faeeb8 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/StringExample1.java @@ -0,0 +1,47 @@ +package com.javaedge.concurrency.example.commonunsafe; + +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@NotThreadSafe +public class StringExample1 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static StringBuilder stringBuilder = new StringBuilder(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + update(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", stringBuilder.length()); + } + + private static void update() { + stringBuilder.append("1"); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/StringExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/StringExample2.java new file mode 100755 index 0000000..a776282 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/commonunsafe/StringExample2.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.commonunsafe; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +/** + * @author JavaEdge + */ +@Slf4j +@ThreadSafe +public class StringExample2 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static StringBuffer stringBuffer = new StringBuffer(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + update(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", stringBuffer.length()); + } + + private static void update() { + stringBuffer.append("1"); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentHashMapExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentHashMapExample.java new file mode 100755 index 0000000..b8c30c8 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentHashMapExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.concurrent; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class ConcurrentHashMapExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Map map = new ConcurrentHashMap<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", map.size()); + } + + private static void update(int i) { + map.put(i, i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentSkipListMapExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentSkipListMapExample.java new file mode 100755 index 0000000..b81407e --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentSkipListMapExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.concurrent; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Map; +import java.util.concurrent.ConcurrentSkipListMap; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class ConcurrentSkipListMapExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Map map = new ConcurrentSkipListMap<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", map.size()); + } + + private static void update(int i) { + map.put(i, i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentSkipListSetExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentSkipListSetExample.java new file mode 100755 index 0000000..1a1833c --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/ConcurrentSkipListSetExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.concurrent; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Set; +import java.util.concurrent.ConcurrentSkipListSet; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class ConcurrentSkipListSetExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Set set = new ConcurrentSkipListSet<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", set.size()); + } + + private static void update(int i) { + set.add(i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/CopyOnWriteArrayListExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/CopyOnWriteArrayListExample.java new file mode 100755 index 0000000..a47d3d6 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/CopyOnWriteArrayListExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.concurrent; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class CopyOnWriteArrayListExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static List list = new CopyOnWriteArrayList<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", list.size()); + } + + private static void update(int i) { + list.add(i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/CopyOnWriteArraySetExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/CopyOnWriteArraySetExample.java new file mode 100755 index 0000000..29d6aad --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/concurrent/CopyOnWriteArraySetExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.concurrent; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Set; +import java.util.concurrent.CopyOnWriteArraySet; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class CopyOnWriteArraySetExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Set set = new CopyOnWriteArraySet<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", set.size()); + } + + private static void update(int i) { + set.add(i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/condition/BlockedQueue.java b/concurrency/src/main/java/com/javaedge/concurrency/example/condition/BlockedQueue.java new file mode 100644 index 0000000..5ce298a --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/condition/BlockedQueue.java @@ -0,0 +1,58 @@ +package com.javaedge.concurrency.example.condition; + +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +/** + * @author JavaEdge + * @date 2021/4/21 + */ +public class BlockedQueue { + + final Lock lock = new ReentrantLock(); + + /** + * 条件变量：队列不满 + */ + final Condition notFull = lock.newCondition(); + + /** + * 条件变量：队列不空 + */ + final Condition notEmpty = lock.newCondition(); + + void enq(T x) { + lock.lock(); + try { +// while (队列已满) { + while (x!=null) { + // 等待队列不满 + notFull.await(); + } + // 省略入队操作 + // 入队后,通知可出队 + notEmpty.signal(); + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + lock.unlock(); + } + } + + void deq() throws InterruptedException { + lock.lock(); + try { +// while (队列已空) { + while (true) { + // 等待队列不空 + notEmpty.await(); + } + // 省略出队操作 + // 出队后，通知可入队 +// notFull.signal(); + } finally { + lock.unlock(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/condition/DubboCondition.java b/concurrency/src/main/java/com/javaedge/concurrency/example/condition/DubboCondition.java new file mode 100644 index 0000000..38b4e04 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/condition/DubboCondition.java @@ -0,0 +1,85 @@ +package com.javaedge.concurrency.example.condition; + +import redis.clients.jedis.Response; + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +/** + * @author JavaEdge + * @date 2021/4/21 + */ +public class DubboCondition { + + Response response; + /** + * 创建锁 + */ + private final Lock lock = new ReentrantLock(); + + /** + * 创建条件变量 + */ + private final Condition done = lock.newCondition(); + + /** + * 调用方通过该方法等待结果 + * + * @param timeout + * @return + */ + Object get(int timeout) throws TimeoutException { + long start = System.nanoTime(); + // 获取锁 + lock.lock(); + try { + while (!isDone()) { + // 获取锁后，通过经典的在循环中调用await()方法来实现等待。 + done.await(timeout, TimeUnit.SECONDS); + long cur = System.nanoTime(); + if (isDone() || + cur - start > timeout) { + break; + } + } + } catch (InterruptedException e) { + e.printStackTrace(); + } finally { + // 释放锁 + lock.unlock(); + } + if (!isDone()) { + throw new TimeoutException(); + } +// return returnFromResponse(); + return null; + } + + /** + * RPC结果是否已经返回 + * + * @return + */ + boolean isDone() { + return response != null; + } + + // RPC结果返回时调用该方法 + private void doReceived(Response res) { + // 获取锁 + lock.lock(); + try { + response = res; + if (done != null) { + // 通知调用线程，结果已经返回，不用继续等待 + done.signal(); + } + } finally { + // 释放锁 + lock.unlock(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample1.java new file mode 100755 index 0000000..7cfc0c1 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample1.java @@ -0,0 +1,47 @@ +package com.javaedge.concurrency.example.count; + +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@NotThreadSafe +public class CountExample1 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static int count = 0; + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count); + } + + private static void add() { + count++; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample2.java new file mode 100755 index 0000000..a386b11 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample2.java @@ -0,0 +1,49 @@ +package com.javaedge.concurrency.example.count; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.atomic.AtomicInteger; + +@Slf4j +@ThreadSafe +public class CountExample2 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static AtomicInteger count = new AtomicInteger(0); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count.get()); + } + + private static void add() { + count.incrementAndGet(); + // count.getAndIncrement(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample3.java new file mode 100755 index 0000000..5a63a03 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample3.java @@ -0,0 +1,47 @@ +package com.javaedge.concurrency.example.count; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class CountExample3 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static int count = 0; + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count); + } + + private synchronized static void add() { + count++; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample4.java b/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample4.java new file mode 100755 index 0000000..0d961f0 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/count/CountExample4.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.count; + +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@NotThreadSafe +public class CountExample4 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static volatile int count = 0; + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count); + } + + private static void add() { + count++; + // 1、count + // 2、+1 + // 3、count + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/deadLock/DeadLock.java b/concurrency/src/main/java/com/javaedge/concurrency/example/deadLock/DeadLock.java new file mode 100755 index 0000000..cf9cfad --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/deadLock/DeadLock.java @@ -0,0 +1,68 @@ +package com.javaedge.concurrency.example.deadLock; + +import lombok.extern.slf4j.Slf4j; + +/** + * 一个简单的死锁类 + * 当DeadLock类的对象flag==1时（td1），先锁定o1,睡眠500毫秒 + * 而td1在睡眠的时候另一个flag==0的对象（td2）线程启动，先锁定o2,睡眠500毫秒 + * td1睡眠结束后需要锁定o2才能继续执行，而此时o2已被td2锁定； + * td2睡眠结束后需要锁定o1才能继续执行，而此时o1已被td1锁定； + * td1、td2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。 + * + * @author JavaEdge + */ +@Slf4j +public class DeadLock implements Runnable { + + public int flag = 1; + + /** + * 静态对象是类的所有对象共享的 + */ + private static final Object O_1 = new Object(); + private static final Object O_2 = new Object(); + + @Override + public void run() { + + log.info("flag:{}", flag); + + if (flag == 1) { + synchronized (O_1) { + try { + Thread.sleep(500); + } catch (Exception e) { + e.printStackTrace(); + } + synchronized (O_2) { + log.info("1"); + } + } + } + + if (flag == 0) { + synchronized (O_2) { + try { + Thread.sleep(500); + } catch (Exception e) { + e.printStackTrace(); + } + synchronized (O_1) { + log.info("0"); + } + } + } + } + + public static void main(String[] args) { + DeadLock td1 = new DeadLock(); + DeadLock td2 = new DeadLock(); + td1.flag = 1; + td2.flag = 0; + // td1,td2都处于可执行状态，但JVM线程调度先执行哪个线程是不确定的 + // td2的run()可能在td1的run()之前运行 + new Thread(td1).start(); + new Thread(td2).start(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample.java new file mode 100755 index 0000000..3e7eb41 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample.java @@ -0,0 +1,69 @@ +package com.javaedge.concurrency.example.forkjoin; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ForkJoinPool; +import java.util.concurrent.Future; +import java.util.concurrent.RecursiveTask; + +/** + * @author JavaEdge + */ +@Slf4j +public class ForkJoinTaskExample extends RecursiveTask { + + public static final int THRESHOLD = 2; + private int start; + private int end; + + public ForkJoinTaskExample(int start, int end) { + this.start = start; + this.end = end; + } + + @Override + protected Integer compute() { + int sum = 0; + + //如果任务足够小就计算任务 + boolean canCompute = (end - start) <= THRESHOLD; + if (canCompute) { + for (int i = start; i <= end; i++) { + sum += i; + } + } else { + // 如果任务大于阈值，就分裂成两个子任务计算 + int middle = (start + end) / 2; + ForkJoinTaskExample leftTask = new ForkJoinTaskExample(start, middle); + ForkJoinTaskExample rightTask = new ForkJoinTaskExample(middle + 1, end); + + // 执行子任务 + leftTask.fork(); + rightTask.fork(); + + // 等待任务执行结束合并其结果 + int leftResult = leftTask.join(); + int rightResult = rightTask.join(); + + // 合并子任务 + sum = leftResult + rightResult; + } + return sum; + } + + public static void main(String[] args) { + ForkJoinPool forkjoinPool = new ForkJoinPool(); + + // 生成一个计算任务，计算1+2+3+4 + ForkJoinTaskExample task = new ForkJoinTaskExample(1, 100); + + // 执行一个任务 + Future result = forkjoinPool.submit(task); + + try { + log.info("result:{}", result.get()); + } catch (Exception e) { + log.error("exception", e); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample2.java new file mode 100755 index 0000000..0047688 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample2.java @@ -0,0 +1,53 @@ +package com.javaedge.concurrency.example.forkjoin; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ForkJoinPool; +import java.util.concurrent.Future; +import java.util.concurrent.RecursiveTask; + +/** + * @author JavaEdge + */ +@Slf4j +public class ForkJoinTaskExample2 { + public static void main(String[] args) { + // 创建分治任务线程池 + ForkJoinPool forkJoinPool = new ForkJoinPool(4); + + // 创建分治任务 + Fibonacci fib = new Fibonacci(30); + + // 启动分治任务 + Integer result = forkJoinPool.invoke(fib); + + System.out.println(result); + } + + /** + * 数列的递归任务 需要有返回值 + */ + static class Fibonacci extends RecursiveTask { + final int n; + + Fibonacci(int n) { + this.n = n; + } + + @Override + protected Integer compute() { + if (n <= 1) { + return n; + } + + Fibonacci f1 = new Fibonacci(n - 1); + + // 创建子任务 + f1.fork(); + Fibonacci f2 = new Fibonacci(n - 2); + + // 等待子任务结果，并合并结果 + return f2.compute() + f1.join(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample3.java new file mode 100755 index 0000000..1aec08d --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/forkjoin/ForkJoinTaskExample3.java @@ -0,0 +1,193 @@ +package com.javaedge.concurrency.example.forkjoin; + +import lombok.extern.slf4j.Slf4j; +import org.junit.Test; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.ForkJoinPool; +import java.util.concurrent.RecursiveTask; + +/** + * @author JavaEdge + */ +@Slf4j +public class ForkJoinTaskExample3 { + + public static void main(String[] args) { + String[] fc = {"hello world", + "hello me", + "hello fork", + "hello join", + "fork join in world"}; + //创建ForkJoin线程池 + ForkJoinPool fjp = new ForkJoinPool(3); + //创建任务 + MR mr = new MR(fc, 0, fc.length); + //启动任务 + Map result = fjp.invoke(mr); + //输出结果 + result.forEach((k, v) -> System.out.println(k + ":" + v)); + } + + /** + * MR模拟类 + */ + static class MR extends RecursiveTask> { + private String[] fc; + private int start, end; + + /** + * 构造函数 + * + * @param fc + * @param fr + * @param to + */ + MR(String[] fc, int fr, int to) { + this.fc = fc; + this.start = fr; + this.end = to; + } + + @Override + protected Map compute() { + if (end - start == 1) { + return calc(fc[start]); + } else { + int mid = (start + end) / 2; + MR mr1 = new MR(fc, start, mid); + // 前半部分数据fork一个递归任务去处理 + mr1.fork(); + MR mr2 = new MR(fc, mid, end); + //计算子任务，并返回合并的结果 后半部分数据则在当前任务中递归处理:mr2.compute() + // 如果join在前面会先首先让当前线程阻塞在join()上。当join()执行完才会执行mr2.compute(),这样并行度会降低 + /** + * 为什么不能merge mr1.compute和mr2..compute或者mr1.join和mr2的join呢？ + * compute+compute相当于没用forkjoin，都在一个线程里跑的。 + * 如果用join+join也可以，不过jdk官方有个建议，顺序要用：a.fork(); b.fork(); b.join(); a.join();否则性能有问题。 + * 所以还是用fork+compute更简单 + */ + return merge(mr2.compute(), mr1.join()); + } + } + + /** + * 合并结果 + * + * @param r1 + * @param r2 + * @return + */ + private Map merge( + Map r1, + Map r2) { + Map result = new HashMap<>(); + result.putAll(r1); + //合并结果 + r2.forEach((k, v) -> { + Long c = result.get(k); + if (c != null) { + result.put(k, c + v); + } else { + result.put(k, v); + } + }); + return result; + } + + //统计单词数量 + private Map + calc(String line) { + Map result = + new HashMap<>(); + //分割单词 + String[] words = + line.split("\\s+"); + //统计单词数量 + for (String w : words) { + Long v = result.get(w); + if (v != null) { + result.put(w, v + 1); + } else { + result.put(w, 1L); + } + } + return result; + } + } + + /** + * Ryzen 1700 8核16线程 3.0 GHz + */ + @Test + public void mergeSort() { + long[] arrs = new long[100000000]; + for (int i = 0; i < 100000000; i++) { + arrs[i] = (long) (Math.random() * 100000000); + } + long startTime = System.currentTimeMillis(); + ForkJoinPool forkJoinPool = new ForkJoinPool(Runtime.getRuntime().availableProcessors()); + MergeSort mergeSort = new MergeSort(arrs); +// arrs = forkJoinPool.invoke(mergeSort); + //传统递归 + arrs = mergeSort(arrs); + long endTime = System.currentTimeMillis(); + System.out.println("耗时：" + (endTime - startTime)); + } + + /** + * 传统递归 + * 耗时： + */ + public static long[] mergeSort(long[] arrs) { + if (arrs.length < 2) { + return arrs; + } + int mid = arrs.length / 2; + long[] left = Arrays.copyOfRange(arrs, 0, mid); + long[] right = Arrays.copyOfRange(arrs, mid, arrs.length); + return merge(mergeSort(left), mergeSort(right)); + } + + public static long[] merge(long[] left, long[] right) { + long[] result = new long[left.length + right.length]; + for (int i = 0, m = 0, j = 0; m < result.length; m++) { + if (i >= left.length) { + result[m] = right[j++]; + } else if (j >= right.length) { + result[m] = left[i++]; + } else if (left[i] > right[j]) { + result[m] = right[j++]; + } else { + result[m] = left[i++]; + } + } + return result; + } + + /** + * fork/join + * 耗时：14853 ms + */ + class MergeSort extends RecursiveTask { + long[] arrs; + + public MergeSort(long[] arrs) { + this.arrs = arrs; + } + + @Override + protected long[] compute() { + if (arrs.length < 2) { + return arrs; + } + int mid = arrs.length / 2; + MergeSort left = new MergeSort(Arrays.copyOfRange(arrs, 0, mid)); + left.fork(); + MergeSort right = new MergeSort(Arrays.copyOfRange(arrs, mid, arrs.length)); + return merge(right.compute(), left.join()); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/furure/guava/FutureExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/guava/FutureExample.java new file mode 100755 index 0000000..9d33971 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/guava/FutureExample.java @@ -0,0 +1,54 @@ +package com.javaedge.concurrency.example.furure.guava; + +import com.google.common.util.concurrent.*; +import lombok.extern.slf4j.Slf4j; + +import javax.annotation.Nullable; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; + +/** + * @author JavaEdge + */ +@Slf4j +public class FutureExample { + + static class MyCallable implements Callable { + + @Override + public String call() throws Exception { + log.info("do something in callable"); + Thread.sleep(5000); + return "Done"; + } + } + + public static void main(String[] args) throws Exception { + // 装饰器模式 + ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(2)); + + ListenableFuture future = service.submit(new MyCallable()); + + System.out.println(future.hashCode()); + + // 异步非阻塞：观察者模式 当ListenableFuture完成时，需要执行的程序 + Futures.addCallback(future, new FutureCallback() { + @Override + public void onSuccess(@Nullable String s) { + + } + + @Override + public void onFailure(Throwable throwable) { + throwable.printStackTrace(); + } + }, service); + + log.info("do something in main"); + Thread.sleep(1000); + String result = future.get(); + log.info("result：{}", result); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletableFutureDemo.java b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletableFutureDemo.java new file mode 100644 index 0000000..84a3d79 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletableFutureDemo.java @@ -0,0 +1,56 @@ +package com.javaedge.concurrency.example.furure.jdk; + +import lombok.AllArgsConstructor; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.*; + +/** + * @author JavaEdge + * @date 2021/4/15 + */ +@Slf4j +public class CompletableFutureDemo { + + @AllArgsConstructor + private static class MyTask implements Callable { + + private String name; + private int timeInSeconds; + private boolean ret; + + @Override + public Boolean call() { + // 模拟业务执行时间 + // 实际中时间不固定，可能在处理计算任务， + try { + Thread.sleep(timeInSeconds); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println(name + " task callback"); + return ret; + } + } + + public static void main(String[] args) throws Exception { + MyTask task1 = new MyTask("task1", 3, true); + MyTask task2 = new MyTask("task2", 4, true); + MyTask task3 = new MyTask("task3", 1, false); + + CompletableFuture f1 = CompletableFuture.supplyAsync(task1::call).thenAccept((result) -> callback(result)); + + CompletableFuture f2 = CompletableFuture.supplyAsync(task2::call).thenAccept((result) -> callback(result)); + + CompletableFuture f3 = CompletableFuture.supplyAsync(task3::call).thenAccept((result) -> callback(result)); + + System.in.read(); + } + + private static void callback(Boolean result) { + if (!result) { + // 处理结束流程 通知其他线程结束（回滚） 超时处理 + System.exit(0); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletableFutureDemo2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletableFutureDemo2.java new file mode 100644 index 0000000..e8b6049 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletableFutureDemo2.java @@ -0,0 +1,66 @@ +package com.javaedge.concurrency.example.furure.jdk; + +import lombok.extern.slf4j.Slf4j; + +import java.util.Random; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; + +/** + * @author JavaEdge + * @date 2021/4/15 + */ +@Slf4j +public class CompletableFutureDemo2 { + + public static void main(String[] args) throws Exception { + CompletableFuture future1 = CompletableFuture + // 1 + .supplyAsync(() -> "Hello World") + // 2 + .thenApply(s -> s + " Java") + // 3 + .thenApply(String::toUpperCase); + System.out.println(future1.join()); + +// CompletableFuture future2 = CompletableFuture +// .supplyAsync(() -> (1 / 0)) +// .thenApply(r -> r * 2); +// System.out.println(future2.join()); + + CompletableFuture future3 = CompletableFuture + .supplyAsync(() -> 1 / 0) + .thenApply(r -> r * 2) + .exceptionally(e -> 0); + System.out.println(future3.join()); + + Random rand = new Random(47); + CompletableFuture f1 = + CompletableFuture.supplyAsync(() -> { + int t = rand.nextInt(20); + try { + Thread.sleep(t); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return String.valueOf(t); + }); + + CompletableFuture f2 = + CompletableFuture.supplyAsync(() -> { + int t = rand.nextInt(); + try { + Thread.sleep(t); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return String.valueOf(t); + }); + + CompletableFuture f3 = + f1.applyToEither(f2, s -> s); + + System.out.println(f3.join()); + + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletionServiceDemo.java b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletionServiceDemo.java new file mode 100644 index 0000000..1c4935d --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/CompletionServiceDemo.java @@ -0,0 +1,144 @@ +package com.javaedge.concurrency.example.furure.jdk; + +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicReference; + +/** + * @author JavaEdge + * @date 2021/4/18 + */ +public class CompletionServiceDemo { + +// public static void main(String[] args) throws InterruptedException, ExecutionException { +// test1(); +// +// test2(); +// +// test3(); +// } + + public static void main(String[] args) throws ExecutionException, InterruptedException { + test0(); + } + + private static void test0() throws ExecutionException, InterruptedException { + ExecutorService executor = Executors.newFixedThreadPool(3); + Future f1 = executor.submit(() -> getPrice1()); + Future f2 = executor.submit(() -> getPrice2()); + Future f3 = executor.submit(() -> getPrice3()); + + executor.execute(() -> { + try { + save(f1.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + }); + executor.execute(() -> { + try { + save(f2.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + }); + executor.execute(() -> { + try { + save(f3.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + }); + f3.get(); + } + + private static AtomicReference test3() { + + ExecutorService executor = Executors.newFixedThreadPool(3); + CompletionService completionService = new ExecutorCompletionService<>(executor); + + // 异步查询价格 + completionService.submit(CompletionServiceDemo::getPrice1); + completionService.submit(CompletionServiceDemo::getPrice2); + completionService.submit(CompletionServiceDemo::getPrice3); + // 将查询结果异步保存 + // 并计算最低价格 + AtomicReference m = new AtomicReference<>(Integer.MAX_VALUE); + for (int i = 0; i < 3; i++) { + executor.execute(() -> { + Integer r = null; + try { + r = completionService.take().get(); + } catch (Exception e) { + e.printStackTrace(); + } + save(r); + m.set(Integer.min(m.get(), r)); + }); + } + return m; + } + + private static void test2() throws InterruptedException, ExecutionException { + ExecutorService executor = Executors.newFixedThreadPool(3); + CompletionService cs = new ExecutorCompletionService<>(executor); + + // 异步查询 + cs.submit(CompletionServiceDemo::getPrice1); + cs.submit(CompletionServiceDemo::getPrice2); + cs.submit(CompletionServiceDemo::getPrice3); + + // 将结果异步保存 + for (int i = 0; i < 3; i++) { + Integer r = cs.take().get(); + executor.execute(() -> save(r)); + } + } + + private static void test1() throws ExecutionException, InterruptedException { + + ExecutorService executor = Executors.newFixedThreadPool(3); + + // 异步查询 + Future f1 = executor.submit(CompletionServiceDemo::getPrice1); + + Future f2 = executor.submit(CompletionServiceDemo::getPrice2); + + Future f3 = executor.submit(CompletionServiceDemo::getPrice3); + + Integer r; + // 获取各个价格并保存 + r = f1.get(); + Integer finalR = r; + executor.execute(() -> save(finalR)); + + r = f2.get(); + Integer finalR1 = r; + executor.execute(() -> save(finalR1)); + + r = f3.get(); + Integer finalR2 = r; + executor.execute(() -> save(finalR2)); + } + + private static void save(Integer r) { + System.out.println("r" + r); + } + + private static Integer getPrice3() { + return 3; + } + + private static Integer getPrice2() { + return 2; + } + + private static Integer getPrice1() { + return 1; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/FutureExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/FutureExample.java new file mode 100755 index 0000000..a4ede87 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/FutureExample.java @@ -0,0 +1,34 @@ +package com.javaedge.concurrency.example.furure.jdk; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; + +/** + * @author JavaEdge + */ +@Slf4j +public class FutureExample { + + static class MyCallable implements Callable { + + @Override + public String call() throws Exception { + log.info("do something in callable"); + Thread.sleep(5000); + return "Done"; + } + } + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + Future future = executorService.submit(new MyCallable()); + log.info("do something in main"); + Thread.sleep(1000); + String result = future.get(); + log.info("result：{}", result); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/FutureTaskExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/FutureTaskExample.java new file mode 100755 index 0000000..1baac34 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/furure/jdk/FutureTaskExample.java @@ -0,0 +1,32 @@ +package com.javaedge.concurrency.example.furure.jdk; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.Callable; +import java.util.concurrent.FutureTask; + +/** + * @author JavaEdge + */ +@Slf4j +public class FutureTaskExample { + + public static void main(String[] args) throws Exception { + // 创建异步任务 + FutureTask futureTask = new FutureTask(new Callable() { + @Override + public String call() throws Exception { + log.info("do something in callable"); + Thread.sleep(5000); + return "Done"; + } + }); + // 启动线程 + new Thread(futureTask).start(); + log.info("do something in main"); + Thread.sleep(1000); + // 【阻塞】等待任务执行完毕，并返回结果 + String result = futureTask.get(); + log.info("result：{}", result); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample1.java new file mode 100755 index 0000000..5797992 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample1.java @@ -0,0 +1,34 @@ +package com.javaedge.concurrency.example.immutable; + +import com.google.common.collect.Maps; +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Map; + +@Slf4j +@NotThreadSafe +public class ImmutableExample1 { + + private final static Integer a = 1; + private final static String b = "2"; + private final static Map map = Maps.newHashMap(); + + static { + map.put(1, 2); + map.put(3, 4); + map.put(5, 6); + } + + public static void main(String[] args) { +// a = 2; +// b = "3"; +// map = Maps.newHashMap(); + map.put(1, 3); + log.info("{}", map.get(1)); + } + + private void test(final int a) { +// a = 1; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample2.java new file mode 100755 index 0000000..126cbf5 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample2.java @@ -0,0 +1,29 @@ +package com.javaedge.concurrency.example.immutable; + +import com.google.common.collect.Maps; +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + + +import java.util.Collections; +import java.util.Map; + +@Slf4j +@ThreadSafe +public class ImmutableExample2 { + + private static Map map = Maps.newHashMap(); + + static { + map.put(1, 2); + map.put(3, 4); + map.put(5, 6); + map = Collections.unmodifiableMap(map); + } + + public static void main(String[] args) { + map.put(1, 3); +// log.info("{}", map.get(1)); + } + +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample3.java new file mode 100755 index 0000000..587cd2d --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/immutable/ImmutableExample3.java @@ -0,0 +1,24 @@ +package com.javaedge.concurrency.example.immutable; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; +import com.javaedge.concurrency.annoations.ThreadSafe; + +@ThreadSafe +public class ImmutableExample3 { + + private final static ImmutableList list = ImmutableList.of(1, 2, 3); + + private final static ImmutableSet set = ImmutableSet.copyOf(list); + + private final static ImmutableMap map = ImmutableMap.of(1, 2, 3, 4); + + private final static ImmutableMap map2 = ImmutableMap.builder() + .put(1, 2).put(3, 4).put(5, 6).build(); + + + public static void main(String[] args) { + System.out.println(map2.get(3)); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/Account.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/Account.java new file mode 100644 index 0000000..a0c9ddb --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/Account.java @@ -0,0 +1,71 @@ +package com.javaedge.concurrency.example.lock; + +import java.util.Random; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + + +/** + * @author JavaEdge + * @date 2021/4/21 + */ +class Account { + + private int balance; + + private final Lock lock = new ReentrantLock(); + + /** + * 转账 + * + * @param target 目标账户 + * @param amount 转账金额 + */ + void errorTransfer(Account target, int amount) { + while (true) { + if (this.lock.tryLock()) { + try { + if (target.lock.tryLock()) { + try { + this.balance -= amount; + target.balance += amount; + } finally { + target.lock.unlock(); + } + } else { + // nothing + } + } finally { + this.lock.unlock(); + } + } else { + // nothing + } + } + } + + void correctTransfer(Account tar, int amt) throws InterruptedException { + while (true) { + if (this.lock.tryLock(new Random().nextLong(), TimeUnit.NANOSECONDS)) { + try { + if (tar.lock.tryLock(new Random().nextLong(), TimeUnit.NANOSECONDS)) { + try { + this.balance -= amt; + tar.balance += amt; + break; + } finally { + tar.lock.unlock(); + } + } else { + // nothing + } + } finally { + this.lock.unlock(); + } + } else { + // nothing + } + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo1.java new file mode 100644 index 0000000..ba872c4 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo1.java @@ -0,0 +1,46 @@ +package com.javaedge.concurrency.example.lock; + +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +/** + * @author JavaEdge + * @date 2021/4/22 + */ +public class CacheDemo1 { + + final Map m = new HashMap(); + + final ReadWriteLock rwl = new ReentrantReadWriteLock(); + + final Lock r = rwl.readLock(); + + final Lock w = rwl.writeLock(); + + Data get(String key) { + r.lock(); + try { + return m.get(key); + } finally { + r.unlock(); + } + } + + Data put(String key, Data v) { + w.lock(); + try { + return m.put(key, v); + } finally { + w.unlock(); + } + } + + class Data { } + + public static void main(String[] args) { + + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo2.java new file mode 100644 index 0000000..5f0f9be --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo2.java @@ -0,0 +1,72 @@ +package com.javaedge.concurrency.example.lock; + +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +/** + * @author JavaEdge + * @date 2021/4/22 + */ +public class CacheDemo2 { + + public static void main(String[] args) { + } + + final Map m = new HashMap<>(); + final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); + final Lock readLock = readWriteLock.readLock(); + final Lock writeLock = readWriteLock.writeLock(); + + V get(K key) { + V v = null; + // 1.加读锁 + readLock.lock(); + try { + // 2.读缓存 + v = m.get(key); + if (v == null) { + writeLock.lock(); + try { + // 再次验证并更新缓存 + } finally { + writeLock.unlock(); + } + } + } finally { + // 3.释放锁 + readLock.unlock(); + } + // 4.缓存中存在，返回 + if (v != null) { + return v; + } + + /** + * 5.若缓存中没有缓存目标对象,就需要从 DB 加载,然后写入缓存. + * 写缓存需要用到写锁 + */ + writeLock.lock(); + try { + + /** + * 6. + * 获取写锁后,并非直接去查询DB. + * 先再验证一次缓存中是否存在,因为高并发场景下,其他线程可能已查询过 DB + */ + v = m.get(key); + // 7 + if (v == null) { + // 再次验证如果还是不存在，才去查询DB + v = null; + // 并更新本地缓存 + m.put(key, v); + } + } finally { + writeLock.unlock(); + } + return v; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo3.java new file mode 100644 index 0000000..213fec9 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/CacheDemo3.java @@ -0,0 +1,59 @@ +package com.javaedge.concurrency.example.lock; + +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +/** + * @author JavaEdge + * @date 2021/4/22 + */ +public class CacheDemo3 { + + Object data; + + volatile boolean cacheValid; + + final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); + + final Lock readLock = readWriteLock.readLock(); + + final Lock writeLock = readWriteLock.writeLock(); + + void processCachedData() { + // 获取读锁 + readLock.lock(); + if (!cacheValid) { + // 释放读锁，因为不允许读锁的升级 + readLock.unlock(); + // 获取写锁 + writeLock.lock(); + try { + // 再次检查状态 + if (!cacheValid) { + // 省略具体代码 + data = null; + cacheValid = true; + } + /** + * 1.获取读锁的时候线程还是持有写锁的 + * 释放写锁前，降级为读锁 + * 这种锁的降级是支持的 + */ + readLock.lock(); + } finally { + // 释放写锁 + writeLock.unlock(); + } + } + // 此处仍持有读锁 + try { + use(data); + } finally { + readLock.unlock(); + } + } + + private void use(Object data) { + } +} \ No newline at end of file diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockDemo.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockDemo.java new file mode 100644 index 0000000..eb9f657 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockDemo.java @@ -0,0 +1,32 @@ +package com.javaedge.concurrency.example.lock; + +/** + * 多线程 原子性 + * + * @author JavaEdge + * @date 2019/10/17 + */ +public class LockDemo { + + volatile int i = 0; + + public void add() { + i++; // i+1 + } + + public static void main(String[] args) throws InterruptedException { + LockDemo ld = new LockDemo(); + + // 期望20000 + for (int i = 0; i < 2; i++) { + new Thread(() -> { + for (int j = 0; j < 10000; j++) { + ld.add(); + } + }).start(); + } + Thread.sleep(2000L); + System.out.println(ld.i); + } +} + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample1.java new file mode 100755 index 0000000..8cd84b0 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample1.java @@ -0,0 +1,51 @@ +package com.javaedge.concurrency.example.lock; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +/** + * @author JavaEdge + * @date 2019/10/17 + */ +@Slf4j +@ThreadSafe +public class LockExample1 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static int count = 0; + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count); + } + + private synchronized static void add() { + count++; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample2.java new file mode 100755 index 0000000..ae631bb --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample2.java @@ -0,0 +1,56 @@ +package com.javaedge.concurrency.example.lock; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +@Slf4j +@ThreadSafe +public class LockExample2 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static int count = 0; + + private final static Lock lock = new ReentrantLock(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal ; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count); + } + + private static void add() { + lock.lock(); + try { + count++; + } finally { + lock.unlock(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample3.java new file mode 100755 index 0000000..d6c0be0 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample3.java @@ -0,0 +1,52 @@ +package com.javaedge.concurrency.example.lock; + +import lombok.extern.slf4j.Slf4j; + +import java.util.Map; +import java.util.Set; +import java.util.TreeMap; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantReadWriteLock; + +@Slf4j +public class LockExample3 { + + private final Map map = new TreeMap<>(); + + private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + + private final Lock readLock = lock.readLock(); + + private final Lock writeLock = lock.writeLock(); + + public Data get(String key) { + readLock.lock(); + try { + return map.get(key); + } finally { + readLock.unlock(); + } + } + + public Set getAllKeys() { + readLock.lock(); + try { + return map.keySet(); + } finally { + readLock.unlock(); + } + } + + public Data put(String key, Data value) { + writeLock.lock(); + try { + return map.put(key, value); + } finally { + readLock.unlock(); + } + } + + class Data { + + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample4.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample4.java new file mode 100755 index 0000000..b775e55 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample4.java @@ -0,0 +1,59 @@ +package com.javaedge.concurrency.example.lock; + +import java.util.concurrent.locks.StampedLock; + +public class LockExample4 { + + class Point { + private double x, y; + private final StampedLock sl = new StampedLock(); + + void move(double deltaX, double deltaY) { // an exclusively locked method + long stamp = sl.writeLock(); + try { + x += deltaX; + y += deltaY; + } finally { + sl.unlockWrite(stamp); + } + } + + //下面看看乐观读锁案例 + double distanceFromOrigin() { // A read-only method + long stamp = sl.tryOptimisticRead(); //获得一个乐观读锁 + double currentX = x, currentY = y; //将两个字段读入本地局部变量 + if (!sl.validate(stamp)) { //检查发出乐观读锁后同时是否有其他写锁发生？ + stamp = sl.readLock(); //如果没有，我们再次获得一个读悲观锁 + try { + currentX = x; // 将两个字段读入本地局部变量 + currentY = y; // 将两个字段读入本地局部变量 + } finally { + sl.unlockRead(stamp); + } + } + return Math.sqrt(currentX * currentX + currentY * currentY); + } + + //下面是悲观读锁案例 + void moveIfAtOrigin(double newX, double newY) { // upgrade + // Could instead start with optimistic, not read mode + long stamp = sl.readLock(); + try { + while (x == 0.0 && y == 0.0) { //循环，检查当前状态是否符合 + long ws = sl.tryConvertToWriteLock(stamp); //将读锁转为写锁 + if (ws != 0L) { //这是确认转为写锁是否成功 + stamp = ws; //如果成功 替换票据 + x = newX; //进行状态改变 + y = newY; //进行状态改变 + break; + } else { //如果不能成功转换为写锁 + sl.unlockRead(stamp); //我们显式释放读锁 + stamp = sl.writeLock(); //显式直接进行写锁 然后再通过循环再试 + } + } + } finally { + sl.unlock(stamp); //释放读锁或写锁 + } + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample5.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample5.java new file mode 100755 index 0000000..b7412e7 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample5.java @@ -0,0 +1,58 @@ +package com.javaedge.concurrency.example.lock; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; +import java.util.concurrent.locks.StampedLock; + +/** + * @author JavaEdge + */ +@Slf4j +@ThreadSafe +public class LockExample5 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + public static int count = 0; + + private final static StampedLock STAMPED_LOCK = new StampedLock(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + executorService.execute(() -> { + try { + semaphore.acquire(); + add(); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("count:{}", count); + } + + private static void add() { + long stamp = STAMPED_LOCK.writeLock(); + try { + count++; + } finally { + STAMPED_LOCK.unlock(stamp); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample6.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample6.java new file mode 100755 index 0000000..f8edb00 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockExample6.java @@ -0,0 +1,43 @@ +package com.javaedge.concurrency.example.lock; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.ReentrantLock; + +/** + * @author JavaEdge + */ +@Slf4j +public class LockExample6 { + + public static void main(String[] args) { + ReentrantLock reentrantLock = new ReentrantLock(); + Condition condition = reentrantLock.newCondition(); + + new Thread(() -> { + try { + reentrantLock.lock(); + log.info("wait signal"); // 1 + condition.await(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + log.info("get signal"); // 4 + reentrantLock.unlock(); + }).start(); + + new Thread(() -> { + reentrantLock.lock(); + log.info("get lock"); // 2 + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + condition.signalAll(); + log.info("send signal ~ "); // 3 + reentrantLock.unlock(); + }).start(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockTest.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockTest.java new file mode 100644 index 0000000..45d76f9 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockTest.java @@ -0,0 +1,25 @@ +package com.javaedge.concurrency.example.lock; + +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +/** + * @author JavaEdge + * @date 2021/4/21 + */ +public class LockTest { + private final Lock reentrantLock = new ReentrantLock(); + int value; + + public void add() { + // 获取锁 + reentrantLock.lock(); + try { + // 若线程 t1 执行 value+=1,那后续线程t2能看到value正确值吗？ + value += 1; + } finally { + // 保证锁能释放 + reentrantLock.unlock(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockTest2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockTest2.java new file mode 100644 index 0000000..59f97a6 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/LockTest2.java @@ -0,0 +1,38 @@ +package com.javaedge.concurrency.example.lock; + +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +/** + * @author JavaEdge + * @date 2021/4/21 + */ +public class LockTest2 { + private final Lock reentrantLock = new ReentrantLock(); + int value; + + public int get() { + // 2.获取锁 + // 此时，若锁可重入，则t1可再次加锁 + // 若不可重入，则t1此时会被阻塞 + reentrantLock.lock(); + try { + return value; + } finally { + // 保证锁能释放 + reentrantLock.unlock(); + } + } + + public void add() { + // 获取锁 + reentrantLock.lock(); + try { + // 1.线程 t1 此时已经获取到锁 + value = 1 + get(); + } finally { + // 确保释放锁 + reentrantLock.unlock(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/Point.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/Point.java new file mode 100644 index 0000000..648d0e2 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/Point.java @@ -0,0 +1,42 @@ +package com.javaedge.concurrency.example.lock; + +import java.util.concurrent.locks.StampedLock; + +/** + * @author JavaEdge + * @date 2021/4/23 + */ +class Point { + private int x, y; + final StampedLock stampedLock = new StampedLock(); + + /** + * 计算到原点的距离 + */ + public int distanceFromOrigin() { + + // 1.乐观读,是无锁的 + long stamp = stampedLock.tryOptimisticRead(); + + // 2.由于乐观读是无锁的，所以共享变量x、y读入局部变量时，x、y可能被其他线程修改 + int curX = x, curY = y; + + /** + * 3.所以读完后，还要再验证是否存在写操作 + * 判断执行读操作期间，是否存在写操作 + * 若存在,则stampedLock.validate会返回false + */ + if (!stampedLock.validate(stamp)) { + // 升级为悲观读锁 + stamp = stampedLock.readLock(); + try { + curX = x; + curY = y; + } finally { + // 释放悲观读锁 + stampedLock.unlockRead(stamp); + } + } + return (int) Math.sqrt(curX * curX + curY * curY); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/lock/TicketLock.java b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/TicketLock.java new file mode 100644 index 0000000..63de487 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/lock/TicketLock.java @@ -0,0 +1,23 @@ +import java.util.concurrent.atomic.AtomicInteger; + +public class TicketLock { + private AtomicInteger serviceNum = new AtomicInteger(); // 服务号 + private AtomicInteger ticketNum = new AtomicInteger(); // 排队号 + + public int lock() { + // 首先原子性地获得一个排队号 + int myTicketNum = ticketNum.getAndIncrement(); + + // 只要当前服务号不是自己的就不断轮询 + while (serviceNum.get() != myTicketNum) { + } + + return myTicketNum; + } + + public void unlock(int myTicket) { + // 只有当前线程拥有者才能释放锁 + int next = myTicket + 1; + serviceNum.compareAndSet(myTicket, next); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/Message.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/Message.java new file mode 100644 index 0000000..9e008a6 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/Message.java @@ -0,0 +1,19 @@ +package com.javaedge.concurrency.example.mq; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import lombok.extern.slf4j.Slf4j; + +import java.util.Date; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +@Data +public class Message { + private Long id; + private String msg; + private Date sendTime; +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/MqController.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/MqController.java new file mode 100644 index 0000000..46d8abe --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/MqController.java @@ -0,0 +1,33 @@ +package com.javaedge.concurrency.example.mq; + +import com.javaedge.concurrency.example.mq.kafka.KafkaSender; +import com.javaedge.concurrency.example.mq.rabbitmq.RabbitMqClient; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.ResponseBody; + +import javax.annotation.Resource; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +@Controller +@RequestMapping("/mq") +public class MqController { + + @Resource + private RabbitMqClient rabbitMqClient; + + @Resource + private KafkaSender kafkaSender; + + @RequestMapping("/send") + @ResponseBody + public String send(@RequestParam("message") String message) { + rabbitMqClient.send(message); + kafkaSender.send(message); + return "success"; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/KafkaReceiver.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/KafkaReceiver.java new file mode 100644 index 0000000..14544cd --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/KafkaReceiver.java @@ -0,0 +1,20 @@ +package com.javaedge.concurrency.example.mq.kafka; + +import lombok.extern.slf4j.Slf4j; +import org.apache.kafka.clients.consumer.ConsumerRecord; +import org.springframework.kafka.annotation.KafkaListener; +import org.springframework.stereotype.Component; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +@Component +@Slf4j +public class KafkaReceiver { + + @KafkaListener(topics = {TopicConstants.TEST}) + public void receive(ConsumerRecord record) { + log.info("record:{}", record); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/KafkaSender.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/KafkaSender.java new file mode 100644 index 0000000..927a7f1 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/KafkaSender.java @@ -0,0 +1,32 @@ +package com.javaedge.concurrency.example.mq.kafka; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.javaedge.concurrency.example.mq.Message; +import lombok.extern.slf4j.Slf4j; +import org.springframework.kafka.core.KafkaTemplate; + +import javax.annotation.Resource; +import java.util.Date; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +@Slf4j +public class KafkaSender { + + @Resource + private KafkaTemplate kafkaTemplate; + + private Gson gson = new GsonBuilder().create(); + + public void send(String msg) { + Message message = new Message(); + message.setId(System.currentTimeMillis()); + message.setMsg(msg); + message.setSendTime(new Date()); + log.info("send message:{}", message); + kafkaTemplate.send(TopicConstants.TEST, gson.toJson(message)); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/TopicConstants.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/TopicConstants.java new file mode 100644 index 0000000..137fe91 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/kafka/TopicConstants.java @@ -0,0 +1,12 @@ +package com.javaedge.concurrency.example.mq.kafka; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +public interface TopicConstants { + + String TEST = "test"; + + String MESSAGE = "message"; +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/QueueConstants.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/QueueConstants.java new file mode 100644 index 0000000..4bc59cf --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/QueueConstants.java @@ -0,0 +1,12 @@ +package com.javaedge.concurrency.example.mq.rabbitmq; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +public interface QueueConstants { + + String TEST = "test"; + + String MESSAGE = "message"; +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqClient.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqClient.java new file mode 100644 index 0000000..b14c6bc --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqClient.java @@ -0,0 +1,26 @@ +package com.javaedge.concurrency.example.mq.rabbitmq; + +import lombok.extern.slf4j.Slf4j; +import org.springframework.amqp.rabbit.core.RabbitTemplate; +import org.springframework.context.annotation.Configuration; + +import javax.annotation.Resource; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +@Slf4j +@Configuration +public class RabbitMqClient { + + @Resource + private RabbitTemplate rabbitTemplate; + + public void send(String message) { + rabbitTemplate.convertAndSend(QueueConstants.TEST,message); + } +} + + + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqConfig.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqConfig.java new file mode 100644 index 0000000..e983afc --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqConfig.java @@ -0,0 +1,21 @@ +package com.javaedge.concurrency.example.mq.rabbitmq; + +import org.springframework.amqp.core.Queue; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +@Configuration +public class RabbitMqConfig { + + @Bean + public Queue queue() { + return new Queue(QueueConstants.TEST); + } +} + + + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqServer.java b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqServer.java new file mode 100644 index 0000000..2e90678 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/mq/rabbitmq/RabbitMqServer.java @@ -0,0 +1,19 @@ +package com.javaedge.concurrency.example.mq.rabbitmq; + +import lombok.extern.slf4j.Slf4j; +import org.springframework.amqp.rabbit.annotation.RabbitListener; +import org.springframework.context.annotation.Configuration; + +/** + * @author JavaEdge + * @date 2019-02-20 + */ +@Slf4j +@Configuration +public class RabbitMqServer { + + @RabbitListener(queues = QueueConstants.TEST) + public void receive(String message) { + log.info("{}", message); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/publish/Escape.java b/concurrency/src/main/java/com/javaedge/concurrency/example/publish/Escape.java new file mode 100755 index 0000000..7dec55b --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/publish/Escape.java @@ -0,0 +1,28 @@ +package com.javaedge.concurrency.example.publish; + +import com.javaedge.concurrency.annoations.NotRecommend; +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +@Slf4j +@NotThreadSafe +@NotRecommend +public class Escape { + + private int thisCanBeEscape = 0; + + public Escape () { + new InnerClass(); + } + + private class InnerClass { + + public InnerClass() { + log.info("{}", Escape.this.thisCanBeEscape); + } + } + + public static void main(String[] args) { + new Escape(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/publish/UnsafePublish.java b/concurrency/src/main/java/com/javaedge/concurrency/example/publish/UnsafePublish.java new file mode 100755 index 0000000..6c9522d --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/publish/UnsafePublish.java @@ -0,0 +1,25 @@ +package com.javaedge.concurrency.example.publish; + +import com.javaedge.concurrency.annoations.NotThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Arrays; + +@Slf4j +@NotThreadSafe +public class UnsafePublish { + + private String[] states = {"a", "b", "c"}; + + public String[] getStates() { + return states; + } + + public static void main(String[] args) { + UnsafePublish unsafePublish = new UnsafePublish(); + log.info("{}", Arrays.toString(unsafePublish.getStates())); + + unsafePublish.getStates()[0] = "d"; + log.info("{}", Arrays.toString(unsafePublish.getStates())); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample1.java new file mode 100755 index 0000000..c4c3954 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample1.java @@ -0,0 +1,27 @@ +package com.javaedge.concurrency.example.singleton; + +import com.javaedge.concurrency.annoations.NotThreadSafe; + +/** + * 懒汉模式 + * 单例实例在第一次使用时进行创建 + */ +@NotThreadSafe +public class SingletonExample1 { + + // 私有构造函数 + private SingletonExample1() { + + } + + // 单例对象 + private static SingletonExample1 instance = null; + + // 静态的工厂方法 + public static SingletonExample1 getInstance() { + if (instance == null) { + instance = new SingletonExample1(); + } + return instance; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample2.java new file mode 100755 index 0000000..e19499c --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample2.java @@ -0,0 +1,24 @@ +package com.javaedge.concurrency.example.singleton; + +import com.javaedge.concurrency.annoations.ThreadSafe; + +/** + * 饿汉模式 + * 单例实例在类装载时进行创建 + */ +@ThreadSafe +public class SingletonExample2 { + + // 私有构造函数 + private SingletonExample2() { + + } + + // 单例对象 + private static SingletonExample2 instance = new SingletonExample2(); + + // 静态的工厂方法 + public static SingletonExample2 getInstance() { + return instance; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample3.java new file mode 100755 index 0000000..e0ca068 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample3.java @@ -0,0 +1,29 @@ +package com.javaedge.concurrency.example.singleton; + +import com.javaedge.concurrency.annoations.NotRecommend; +import com.javaedge.concurrency.annoations.ThreadSafe; + +/** + * 懒汉模式 + * 单例实例在第一次使用时进行创建 + */ +@ThreadSafe +@NotRecommend +public class SingletonExample3 { + + // 私有构造函数 + private SingletonExample3() { + + } + + // 单例对象 + private static SingletonExample3 instance = null; + + // 静态的工厂方法 + public static synchronized SingletonExample3 getInstance() { + if (instance == null) { + instance = new SingletonExample3(); + } + return instance; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample4.java b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample4.java new file mode 100755 index 0000000..611278d --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample4.java @@ -0,0 +1,41 @@ +package com.javaedge.concurrency.example.singleton; + +import com.javaedge.concurrency.annoations.NotThreadSafe; + +/** + * 懒汉模式 -》 双重同步锁单例模式 + * 单例实例在第一次使用时进行创建 + */ +@NotThreadSafe +public class SingletonExample4 { + + // 私有构造函数 + private SingletonExample4() { + + } + + // 1、memory = allocate() 分配对象的内存空间 + // 2、ctorInstance() 初始化对象 + // 3、instance = memory 设置instance指向刚分配的内存 + + // JVM和cpu优化，发生了指令重排 + + // 1、memory = allocate() 分配对象的内存空间 + // 3、instance = memory 设置instance指向刚分配的内存 + // 2、ctorInstance() 初始化对象 + + // 单例对象 + private static SingletonExample4 instance = null; + + // 静态的工厂方法 + public static SingletonExample4 getInstance() { + if (instance == null) { // 双重检测机制 // B + synchronized (SingletonExample4.class) { // 同步锁 + if (instance == null) { + instance = new SingletonExample4(); // A - 3 + } + } + } + return instance; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample5.java b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample5.java new file mode 100755 index 0000000..f4c6dfd --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample5.java @@ -0,0 +1,35 @@ +package com.javaedge.concurrency.example.singleton; + +import com.javaedge.concurrency.annoations.ThreadSafe; + +/** + * 懒汉模式 -》 双重同步锁单例模式 + * 单例实例在第一次使用时进行创建 + */ +@ThreadSafe +public class SingletonExample5 { + + // 私有构造函数 + private SingletonExample5() { + + } + + // 1、memory = allocate() 分配对象的内存空间 + // 2、ctorInstance() 初始化对象 + // 3、instance = memory 设置instance指向刚分配的内存 + + // 单例对象 volatile + 双重检测机制 -> 禁止指令重排 + private volatile static SingletonExample5 instance = null; + + // 静态的工厂方法 + public static SingletonExample5 getInstance() { + if (instance == null) { // 双重检测机制 // B + synchronized (SingletonExample5.class) { // 同步锁 + if (instance == null) { + instance = new SingletonExample5(); // A - 3 + } + } + } + return instance; + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample6.java b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample6.java new file mode 100755 index 0000000..8d02e5e --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample6.java @@ -0,0 +1,33 @@ +package com.javaedge.concurrency.example.singleton; + +import com.javaedge.concurrency.annoations.ThreadSafe; + +/** + * 饿汉模式 + * 单例实例在类装载时进行创建 + */ +@ThreadSafe +public class SingletonExample6 { + + // 私有构造函数 + private SingletonExample6() { + + } + + // 单例对象 + private static SingletonExample6 instance = null; + + static { + instance = new SingletonExample6(); + } + + // 静态的工厂方法 + public static SingletonExample6 getInstance() { + return instance; + } + + public static void main(String[] args) { + System.out.println(getInstance().hashCode()); + System.out.println(getInstance().hashCode()); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample7.java b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample7.java new file mode 100755 index 0000000..4475432 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/singleton/SingletonExample7.java @@ -0,0 +1,36 @@ +package com.javaedge.concurrency.example.singleton; + +import com.javaedge.concurrency.annoations.Recommend; +import com.javaedge.concurrency.annoations.ThreadSafe; + +/** + * 枚举模式：最安全 + */ +@ThreadSafe +@Recommend +public class SingletonExample7 { + + // 私有构造函数 + private SingletonExample7() { + + } + + public static SingletonExample7 getInstance() { + return Singleton.INSTANCE.getInstance(); + } + + private enum Singleton { + INSTANCE; + + private SingletonExample7 singleton; + + // JVM保证这个方法绝对只调用一次 + Singleton() { + singleton = new SingletonExample7(); + } + + public SingletonExample7 getInstance() { + return singleton; + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/streams/ParallelPrime.java b/concurrency/src/main/java/com/javaedge/concurrency/example/streams/ParallelPrime.java new file mode 100644 index 0000000..53d05ab --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/streams/ParallelPrime.java @@ -0,0 +1,40 @@ +package com.javaedge.concurrency.example.streams; + +import com.javaedge.concurrency.common.Timer; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.nio.file.StandardOpenOption; +import java.util.List; +import java.util.stream.Collectors; + +import static java.util.stream.LongStream.iterate; +import static java.util.stream.LongStream.rangeClosed; + +/** + * @author JavaEdge + */ +public class ParallelPrime { + static final int COUNT = 100_000; + + public static boolean isPrime(long n) { + return rangeClosed(2, (long) Math.sqrt(n)) + .noneMatch(i -> n % i == 0); + } + + public static void main(String[] args) + throws IOException { + Timer timer = new Timer(); + List primes = + iterate(2, i -> i + 1) + .parallel() + .filter(ParallelPrime::isPrime) + .limit(COUNT) + .mapToObj(Long::toString) + .collect(Collectors.toList()); + System.out.println(timer.duration()); + Files.write(Paths.get("primes.txt"), primes, + StandardOpenOption.CREATE); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/streams/Summing.java b/concurrency/src/main/java/com/javaedge/concurrency/example/streams/Summing.java new file mode 100644 index 0000000..f0f73ae --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/streams/Summing.java @@ -0,0 +1,44 @@ +package com.javaedge.concurrency.example.streams; + +import com.javaedge.concurrency.common.Timer; + +import java.util.function.LongSupplier; +import java.util.stream.LongStream; + +/** + * @author JavaEdge + */ +public class Summing { + static void timeTest(String id, long checkValue, LongSupplier operation) { + System.out.print(id + ": "); + Timer timer = new Timer(); + long result = operation.getAsLong(); + if (result == checkValue) { + System.out.println(timer.duration() + "ms"); + } else { + System.out.format("result: %d%ncheckValue: %d%n", result, checkValue); + } + } + + public static final int SZ = 100_000_000; + /** + * Gauss's formula + */ + public static final long CHECK = (long) SZ * ((long) SZ + 1) / 2; + + public static void main(String[] args) { + System.out.println(CHECK); + timeTest("Sum Stream", CHECK, () -> + LongStream.rangeClosed(0, SZ).sum()); + timeTest("Sum Stream Parallel", CHECK, () -> + LongStream.rangeClosed(0, SZ).parallel().sum()); + timeTest("Sum Iterated", CHECK, () -> + LongStream.iterate(0, i -> i + 1) + .limit(SZ + 1).sum()); + // Slower & runs out of memory above 1_000_000: + // timeTest("Sum Iterated Parallel", CHECK, () -> + // LongStream.iterate(0, i -> i + 1) + // .parallel() + // .limit(SZ+1).sum()); + } +} \ No newline at end of file diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo1.java new file mode 100755 index 0000000..7fea598 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo1.java @@ -0,0 +1,35 @@ +package com.javaedge.concurrency.example.sync; + +/** + * 锁 方法(静态/非静态),代码块(对象/类) + * + * @author JavaEdge + * @date 2019/10/20 + */ +public class ObjectSyncDemo1 { + + static Object temp = new Object(); + + // 方法上面：锁的对象 是 类的一个实例 + public void test1() { + // 类锁(class对象，静态方法)，实例锁(this，普通方法) + synchronized (this) { + try { + System.out.println(Thread.currentThread() + " 我开始执行"); + Thread.sleep(3000L); + System.out.println(Thread.currentThread() + " 我执行结束"); + } catch (InterruptedException e) { + } + } + } + + public static void main(String[] args) throws InterruptedException { + new Thread(() -> new ObjectSyncDemo1().test1()).start(); + + // 等1秒钟,让前一个线程启动起来 + Thread.sleep(1000L); + new Thread(() -> { + new ObjectSyncDemo1().test1(); + }).start(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo2.java new file mode 100755 index 0000000..4124e65 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo2.java @@ -0,0 +1,18 @@ +package com.javaedge.concurrency.example.sync; + +// 可重入 +public class ObjectSyncDemo2 { + + public synchronized void test1(Object arg) { + // 继续执行，保证能读取到之前的修改 JMM + System.out.println(Thread.currentThread() + " 我开始执行 " + arg); + if (arg == null) { + test1(new Object()); + } + System.out.println(Thread.currentThread() + " 我执行结束" + arg); + } + + public static void main(String[] args) throws InterruptedException { + new ObjectSyncDemo2().test1(null); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo3.java new file mode 100755 index 0000000..f6a25e7 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo3.java @@ -0,0 +1,22 @@ +package com.javaedge.concurrency.example.sync; + +// 锁粗化(运行时 jit 编译优化) +// jit 编译后的汇编内容, jitwatch可视化工具进行查看 +public class ObjectSyncDemo3 { + int i; + + public void test1(Object arg) { + synchronized (this) { + i++; + // } + // synchronized (this) { + i++; + } + } + + public static void main(String[] args) throws InterruptedException { + for (int i = 0; i < 10000000; i++) { + new ObjectSyncDemo3().test1("a"); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo4.java b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo4.java new file mode 100755 index 0000000..8cf9d70 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/ObjectSyncDemo4.java @@ -0,0 +1,33 @@ +package com.javaedge.concurrency.example.sync; + +// 锁消除(jit) +public class ObjectSyncDemo4 { + public void test3(Object arg) { + StringBuilder builder = new StringBuilder(); + builder.append("a"); + builder.append(arg); + builder.append("c"); + System.out.println(arg.toString()); + } + + public void test2(Object arg) { + String a = "a"; + String c = "c"; + System.out.println(a + arg + c); + } + + public void test1(Object arg) { + // jit 优化, 消除了锁 （Buffer 实例 局部变量） + StringBuffer stringBuffer = new StringBuffer(); + stringBuffer.append("a"); + stringBuffer.append(arg); + stringBuffer.append("c"); + // System.out.println(stringBuffer.toString()); + } + + public static void main(String[] args) throws InterruptedException { + for (int i = 0; i < 1000000; i++) { + new ObjectSyncDemo4().test1("123"); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/sync/SynchronizedExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/SynchronizedExample1.java new file mode 100755 index 0000000..9ba8ced --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/SynchronizedExample1.java @@ -0,0 +1,47 @@ +package com.javaedge.concurrency.example.sync; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +/** + * + * @author JavaEdge + * @date 2019/10/20 + */ +@Slf4j +public class SynchronizedExample1 { + + /** + * 修饰一个代码块 + * + * @param j + */ + public void test1(int j) { + synchronized (this) { + for (int i = 0; i < 10; i++) { + log.info("test1 {} - {}", j, i); + } + } + } + + /** + * 修饰一个方法 + * + * @param j + */ + public synchronized void test2(int j) { + for (int i = 0; i < 10; i++) { + log.info("test2 {} - {}", j, i); + } + } + + public static void main(String[] args) { + SynchronizedExample1 example1 = new SynchronizedExample1(); + SynchronizedExample1 example2 = new SynchronizedExample1(); + ExecutorService executorService = Executors.newCachedThreadPool(); + executorService.execute(() -> example1.test2(1)); + executorService.execute(() -> example2.test2(2)); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/sync/SynchronizedExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/SynchronizedExample2.java new file mode 100755 index 0000000..e43490e --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/sync/SynchronizedExample2.java @@ -0,0 +1,40 @@ +package com.javaedge.concurrency.example.sync; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + + +/** + * + * @author JavaEdge + * @date 2019/10/20 + */ +@Slf4j +public class SynchronizedExample2 { + + // 修饰一个类 + public static void test1(int j) { + synchronized (SynchronizedExample2.class) { + for (int i = 0; i < 10; i++) { + log.info("test1 {} - {}", j, i); + } + } + } + + // 修饰一个静态方法 + public static synchronized void test2(int j) { + for (int i = 0; i < 10; i++) { + log.info("test2 {} - {}", j, i); + } + } + + public static void main(String[] args) { + SynchronizedExample2 example1 = new SynchronizedExample2(); + SynchronizedExample2 example2 = new SynchronizedExample2(); + ExecutorService executorService = Executors.newCachedThreadPool(); + executorService.execute(() -> example1.test1(1)); + executorService.execute(() -> example2.test1(2)); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample1.java new file mode 100755 index 0000000..81acbb9 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample1.java @@ -0,0 +1,51 @@ +package com.javaedge.concurrency.example.syncContainer; + +import com.google.common.collect.Lists; +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Collections; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class CollectionsExample1 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static List list = Collections.synchronizedList(Lists.newArrayList()); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", list.size()); + } + + private static void update(int i) { + list.add(i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample2.java new file mode 100755 index 0000000..951cfbb --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample2.java @@ -0,0 +1,51 @@ +package com.javaedge.concurrency.example.syncContainer; + +import com.google.common.collect.Sets; +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Collections; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class CollectionsExample2 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Set set = Collections.synchronizedSet(Sets.newHashSet()); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", set.size()); + } + + private static void update(int i) { + set.add(i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample3.java new file mode 100755 index 0000000..e4a7bce --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/CollectionsExample3.java @@ -0,0 +1,51 @@ +package com.javaedge.concurrency.example.syncContainer; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class CollectionsExample3 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Map map = Collections.synchronizedMap(new HashMap<>()); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", map.size()); + } + + private static void update(int i) { + map.put(i, i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/HashTableExample.java b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/HashTableExample.java new file mode 100755 index 0000000..fa11482 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/HashTableExample.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.syncContainer; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.Hashtable; +import java.util.Map; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class HashTableExample { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static Map map = new Hashtable<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", map.size()); + } + + private static void update(int i) { + map.put(i, i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample1.java new file mode 100755 index 0000000..9a3251e --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample1.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.syncContainer; + +import com.javaedge.concurrency.annoations.ThreadSafe; +import lombok.extern.slf4j.Slf4j; + +import java.util.List; +import java.util.Vector; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Semaphore; + +@Slf4j +@ThreadSafe +public class VectorExample1 { + + // 请求总数 + public static int clientTotal = 5000; + + // 同时并发执行的线程数 + public static int threadTotal = 200; + + private static List list = new Vector<>(); + + public static void main(String[] args) throws Exception { + ExecutorService executorService = Executors.newCachedThreadPool(); + final Semaphore semaphore = new Semaphore(threadTotal); + final CountDownLatch countDownLatch = new CountDownLatch(clientTotal); + for (int i = 0; i < clientTotal; i++) { + final int count = i; + executorService.execute(() -> { + try { + semaphore.acquire(); + update(count); + semaphore.release(); + } catch (Exception e) { + log.error("exception", e); + } + countDownLatch.countDown(); + }); + } + countDownLatch.await(); + executorService.shutdown(); + log.info("size:{}", list.size()); + } + + private static void update(int i) { + list.add(i); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample2.java new file mode 100755 index 0000000..80273bd --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample2.java @@ -0,0 +1,39 @@ +package com.javaedge.concurrency.example.syncContainer; + +import com.javaedge.concurrency.annoations.NotThreadSafe; + +import java.util.Vector; + +@NotThreadSafe +public class VectorExample2 { + + private static Vector vector = new Vector<>(); + + public static void main(String[] args) { + + while (true) { + + for (int i = 0; i < 10; i++) { + vector.add(i); + } + + Thread thread1 = new Thread() { + public void run() { + for (int i = 0; i < vector.size(); i++) { + vector.remove(i); + } + } + }; + + Thread thread2 = new Thread() { + public void run() { + for (int i = 0; i < vector.size(); i++) { + vector.get(i); + } + } + }; + thread1.start(); + thread2.start(); + } + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample3.java new file mode 100755 index 0000000..427a7ef --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/syncContainer/VectorExample3.java @@ -0,0 +1,45 @@ +package com.javaedge.concurrency.example.syncContainer; + +import java.util.Iterator; +import java.util.Vector; + +public class VectorExample3 { + + // java.util.ConcurrentModificationException + private static void test1(Vector v1) { // foreach + for(Integer i : v1) { + if (i.equals(3)) { + v1.remove(i); + } + } + } + + // java.util.ConcurrentModificationException + private static void test2(Vector v1) { // iterator + Iterator iterator = v1.iterator(); + while (iterator.hasNext()) { + Integer i = iterator.next(); + if (i.equals(3)) { + v1.remove(i); + } + } + } + + // success + private static void test3(Vector v1) { // for + for (int i = 0; i < v1.size(); i++) { + if (v1.get(i).equals(3)) { + v1.remove(i); + } + } + } + + public static void main(String[] args) { + + Vector vector = new Vector<>(); + vector.add(1); + vector.add(2); + vector.add(3); + test1(vector); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadLocal/RequestHolder.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadLocal/RequestHolder.java new file mode 100755 index 0000000..5847b29 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadLocal/RequestHolder.java @@ -0,0 +1,23 @@ +package com.javaedge.concurrency.example.threadLocal; + +/** + * + * @author JavaEdge + * @date 2019/10/9 + */ +public class RequestHolder { + + private final static ThreadLocal requestHolder = new ThreadLocal<>(); + + public static void add(Long id) { + requestHolder.set(id); + } + + public static Long getId() { + return requestHolder.get(); + } + + public static void remove() { + requestHolder.remove(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadLocal/ThreadLocalController.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadLocal/ThreadLocalController.java new file mode 100755 index 0000000..031e5f2 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadLocal/ThreadLocalController.java @@ -0,0 +1,21 @@ +package com.javaedge.concurrency.example.threadLocal; + +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.ResponseBody; + +/** + * + * @author JavaEdge + * @date 2019/10/9 + */ +@Controller +@RequestMapping("/threadLocal") +public class ThreadLocalController { + + @RequestMapping("/test") + @ResponseBody + public Long test() { + return RequestHolder.getId(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadpermessage/EchoServer.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpermessage/EchoServer.java new file mode 100644 index 0000000..bb7cdac --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpermessage/EchoServer.java @@ -0,0 +1,52 @@ +package com.javaedge.concurrency.example.threadpermessage; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.net.InetSocketAddress; +import java.nio.ByteBuffer; +import java.nio.channels.ServerSocketChannel; +import java.nio.channels.SocketChannel; + +/** + * 回显从客户端收到的数据 + * + * @author JavaEdge + */ +public final class EchoServer { + + public static void main(String[] args) throws Exception { + final ServerSocketChannel ssc = ServerSocketChannel.open().bind( + new InetSocketAddress(8080)); + // 处理请求 + try { + while (true) { + // 接收请求 + SocketChannel sc = ssc.accept(); + // 每个请求都创建一个线程 + new Thread(() -> { + try { + // 读Socket + ByteBuffer rb = ByteBuffer.allocateDirect(1024); + sc.read(rb); + //模拟处理请求 + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + // 写Socket + ByteBuffer wb = (ByteBuffer) rb.flip(); + sc.write(wb); + // 关闭Socket + sc.close(); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + }).start(); + } + } finally { + ssc.close(); + } + } +} + diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/MyThreadPool.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/MyThreadPool.java new file mode 100644 index 0000000..0eb1cea --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/MyThreadPool.java @@ -0,0 +1,70 @@ +package com.javaedge.concurrency.example.threadpool; + +import com.google.common.collect.Lists; +import lombok.SneakyThrows; + +import java.util.List; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; + +/** + * 简化线程池 + * + * @author JavaEdge + * @date 2021/5/16 + */ +public class MyThreadPool { + + /** + * 利用阻塞队列实现生产者-消费者模式 + */ + BlockingQueue workQueue; + + /** + * 保存内部工作线程 + */ + List threads = Lists.newArrayList(); + + MyThreadPool(int poolSize, BlockingQueue workQueue) { + this.workQueue = workQueue; + // 创建工作线程 + for (int idx = 0; idx < poolSize; idx++) { + WorkerThread work = new WorkerThread(); + work.start(); + threads.add(work); + } + } + + /** + * 提交任务 + */ + void execute(Runnable command) throws InterruptedException { + // 将任务加入到workQueue + workQueue.put(command); + } + + /** + * 工作线程：负责消费任务，并执行任务 + */ + class WorkerThread extends Thread { + + @SneakyThrows + @Override + public void run() { + // 消费workQueue中的任务并执行 + while (true) { + Runnable task = workQueue.take(); + task.run(); + } + } + } + + public static void main(String[] args) throws InterruptedException { + // 创建有界阻塞队列 + BlockingQueue workQueue = new LinkedBlockingQueue<>(2); + // 创建线程池 + MyThreadPool pool = new MyThreadPool(10, workQueue); + // 提交任务 + pool.execute(() -> System.out.println("hello")); + } +} \ No newline at end of file diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPool2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPool2.java new file mode 100644 index 0000000..f7814b9 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPool2.java @@ -0,0 +1,50 @@ +package com.javaedge.concurrency.example.threadpool; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +/** + * @author JavaEdge + */ +public class ThreadPool2 { + + public static void main(String[] args) throws InterruptedException { + // P1、P2阶段共用的线程池 + ExecutorService executorService = Executors.newFixedThreadPool(2); + // P1阶段的闭锁 + CountDownLatch p1 = new CountDownLatch(2); + for (int i = 0; i < 2; i++) { + System.out.println("P1"); + //执行P1阶段任务 + executorService.execute(() -> { + // P2阶段的闭锁 + CountDownLatch p2 = new CountDownLatch(2); + // 执行P2阶段子任务 + for (int j = 0; j < 2; j++) { + executorService.execute(() -> { + System.out.println("P2"); + p2.countDown(); + }); + } + + try { + + /** + * 等待P2阶段任务执行完 + * 线程池里所有的线程都在等待P2阶段任务执行完 + * P2阶段任务何时能执行完？ + * 永远都无法执行完！因为线程池里的线程都被阻塞了，没有空闲线程执行P2阶段任务。 + */ + p2.await(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + p1.countDown(); + }); + } + // 等着P1阶段任务执行完 + p1.await(); + System.out.println("end"); + } +} \ No newline at end of file diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample1.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample1.java new file mode 100755 index 0000000..20b963e --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample1.java @@ -0,0 +1,26 @@ +package com.javaedge.concurrency.example.threadpool; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +/** + * + * @author JavaEdge + * @date 2019/10/9 + */ +@Slf4j +public class ThreadPoolExample1 { + + public static void main(String[] args) { + + ExecutorService executorService = Executors.newCachedThreadPool(); + + for (int i = 0; i < 10; i++) { + final int index = i; + executorService.execute(() -> log.info("task:{}", index)); + } + executorService.shutdown(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample2.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample2.java new file mode 100755 index 0000000..5191771 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample2.java @@ -0,0 +1,26 @@ +package com.javaedge.concurrency.example.threadpool; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +/** + * + * @author JavaEdge + * @date 2019/10/9 + */ +@Slf4j +public class ThreadPoolExample2 { + + public static void main(String[] args) { + + ExecutorService executorService = Executors.newFixedThreadPool(3); + + for (int i = 0; i < 10; i++) { + final int index = i; + executorService.execute(() -> log.info("task:{}", index)); + } + executorService.shutdown(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample3.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample3.java new file mode 100755 index 0000000..255d290 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample3.java @@ -0,0 +1,26 @@ +package com.javaedge.concurrency.example.threadpool; + +import lombok.extern.slf4j.Slf4j; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +/** + * + * @author JavaEdge + * @date 2019/10/9 + */ +@Slf4j +public class ThreadPoolExample3 { + + public static void main(String[] args) { + + ExecutorService executorService = Executors.newSingleThreadExecutor(); + + for (int i = 0; i < 10; i++) { + final int index = i; + executorService.execute(() -> log.info("task:{}", index)); + } + executorService.shutdown(); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample4.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample4.java new file mode 100755 index 0000000..869b627 --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample4.java @@ -0,0 +1,42 @@ +package com.javaedge.concurrency.example.threadpool; + +import lombok.extern.slf4j.Slf4j; + +import java.util.Date; +import java.util.Timer; +import java.util.TimerTask; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +/** + * + * @author JavaEdge + * @date 2019/10/9 + */ +@Slf4j +public class ThreadPoolExample4 { + + public static void main(String[] args) { + + ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1); + +// executorService.schedule(new Runnable() { +// @Override +// public void run() { +// log.warn("schedule run"); +// } +// }, 3, TimeUnit.SECONDS); + + executorService.scheduleAtFixedRate(() -> log.warn("schedule run"), 1, 3, TimeUnit.SECONDS); +// executorService.shutdown(); + + Timer timer = new Timer(); + timer.schedule(new TimerTask() { + @Override + public void run() { + log.warn("timer run"); + } + }, new Date(), 5 * 1000); + } +} diff --git a/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample5.java b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample5.java new file mode 100644 index 0000000..61de37a --- /dev/null +++ b/concurrency/src/main/java/com/javaedge/concurrency/example/threadpool/ThreadPoolExample5.java @@ -0,0 +1,275 @@ +package com.javaedge.concurrency.example.threadpool; + +import org.testng.annotations.Test; + +import java.util.List; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.RejectedExecutionHandler; +import java.util.concurrent.ScheduledThreadPoolExecutor; +import java.util.concurrent.SynchronousQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +/** + * 线程池的使用 + * + * @author JavaEdge + * @date 2019/10/11 + */ +public class ThreadPoolExample5 { + + /** + * 测试： 提交15个执行时间需要3秒的任务,看线程池的状况 + * + * @param threadPoolExecutor 传入不同的线程池，看不同的结果 + * @throws Exception + */ + public void testCommon(ThreadPoolExecutor threadPoolExecutor) throws Exception { + // 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况 + for (int i = 0; i < 15; i++) { + int n = i; + threadPoolExecutor.submit(() -> { + try { + System.out.println("开始执行：" + n); + Thread.sleep(3000L); + System.err.println("执行结束:" + n); + } catch (InterruptedException e) { + e.printStackTrace(); + } + }); + System.out.println("任务提交成功 :" + i); + } + // 查看线程数量，查看队列等待数量 + Thread.sleep(500L); + System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize()); + System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size()); + // 等待15秒，查看线程数量和队列数量（理论上，会被超出核心线程数量的线程自动销毁） + Thread.sleep(15000L); + System.out.println("当前线程池线程数量为：" + threadPoolExecutor.getPoolSize()); + System.out.println("当前线程池等待的数量为：" + threadPoolExecutor.getQueue().size()); + } + + @Test + private void threadPoolExecutorTest1() throws Exception { + ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, + 5, + TimeUnit.SECONDS, + new LinkedBlockingQueue<>()); + + testCommon(threadPoolExecutor); + // 预计结果：线程池线程数量为：5,超出数量的任务，其他的进入队列中等待被执行 + } + + @Test + private void threadPoolExecutorTest2() throws Exception { + // 最大容纳13个任务。 + // 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy + ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, + TimeUnit.SECONDS, + new LinkedBlockingQueue<>(3), (r, executor) -> System.err.println("有任务被拒绝执行了")); + testCommon(threadPoolExecutor); + + // 预计结果： + // 1、 5个任务直接分配线程开始执行 + // 2、 3个任务进入等待队列 + // 3、 队列不够用，临时加开5个线程来执行任务(5秒没活干就销毁) + // 4、 队列和线程池都满了，剩下2个任务，没资源了，被拒绝执行。 + // 5、 任务执行，5秒后，如果无任务可执行，销毁临时创建的5个线程 + } + + /** + * 3、 线程池信息： 核心线程数量5，最大数量5，无界队列，超出核心线程数量的线程存活时间：5秒 + * + * @throws Exception + */ + private void threadPoolExecutorTest3() throws Exception { + // 等同于 Executors.newFixedThreadPool(int nThreads) + ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0L, + TimeUnit.MILLISECONDS, + new LinkedBlockingQueue<>()); + testCommon(threadPoolExecutor); + // 预计：线程池线程数量为：5，超出数量的任务，其他的进入队列中等待被执行 + } + + /** + * 4、 线程池信息： + * 核心线程数量0，最大数量Integer.MAX_VALUE，SynchronousQueue队列，超出核心线程数量的线程存活时间：60秒 + * + * @throws Exception + */ + private void threadPoolExecutorTest4() throws Exception { + + // SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待着把元素加入或移出队列。 + // 在使用SynchronousQueue作为工作队列的前提下，客户端代码向线程池提交任务时， + // 而线程池中又没有空闲的线程能够从SynchronousQueue队列实例中取一个任务， + // 那么相应的offer方法调用就会失败（即任务没有被存入工作队列）。 + // 此时，ThreadPoolExecutor会新建一个新的工作者线程用于对这个入队列失败的任务进行处理（假设此时线程池的大小还未达到其最大线程池大小maximumPoolSize）。 + + // 和Executors.newCachedThreadPool()一样的 + ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, + new SynchronousQueue()); + testCommon(threadPoolExecutor); + // 预计结果： + // 1、 线程池线程数量为：15，超出数量的任务，其他的进入队列中等待被执行 + // 2、 所有任务执行结束，60秒后，如果无任务可执行，所有线程全部被销毁，池的大小恢复为0 + Thread.sleep(60000L); + System.out.println("60秒后，再看线程池中的数量：" + threadPoolExecutor.getPoolSize()); + } + + /** + * 5、 定时执行线程池信息：3秒后执行，一次性任务，到点就执行
+ * 核心线程数量5，最大数量Integer.MAX_VALUE，DelayedWorkQueue延时队列，超出核心线程数量的线程存活时间：0秒 + * + * @throws Exception + */ + private void threadPoolExecutorTest5() throws Exception { + // 和Executors.newScheduledThreadPool()一样的 + ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5); + threadPoolExecutor.schedule(new Runnable() { + @Override + public void run() { + System.out.println("任务被执行，现在时间：" + System.currentTimeMillis()); + } + }, 3000, TimeUnit.MILLISECONDS); + System.out.println( + "定时任务，提交成功，时间是：" + System.currentTimeMillis() + ", 当前线程池中线程数量：" + threadPoolExecutor.getPoolSize()); + // 预计结果：任务在3秒后被执行一次 + } + + /** + * 6、 定时执行线程池信息：线程固定数量5 ，
+ * 核心线程数量5，最大数量Integer.MAX_VALUE，DelayedWorkQueue延时队列，超出核心线程数量的线程存活时间：0秒 + * + * @throws Exception + */ + private void threadPoolExecutorTest6() throws Exception { + ScheduledThreadPoolExecutor threadPoolExecutor = new ScheduledThreadPoolExecutor(5); + // 周期性执行某一个任务，线程池提供了两种调度方式，这里单独演示一下。测试场景一样。 + // 测试场景：提交的任务需要3秒才能执行完毕。看两种不同调度方式的区别 + // 效果1： 提交后，2秒后开始第一次执行，之后每间隔1秒，固定执行一次(如果发现上次执行还未完毕，则等待完毕，完毕后立刻执行)。 + // 也就是说这个代码中是，3秒钟执行一次（计算方式：每次执行三秒，间隔时间1秒，执行结束后马上开始下一次执行，无需等待） + threadPoolExecutor.scheduleAtFixedRate(new Runnable() { + @Override + public void run() { + try { + Thread.sleep(3000L); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("任务-1 被执行，现在时间：" + System.currentTimeMillis()); + } + }, 2000, 1000, TimeUnit.MILLISECONDS); + + // 效果2：提交后，2秒后开始第一次执行，之后每间隔1秒，固定执行一次(如果发现上次执行还未完毕，则等待完毕，等上一次执行完毕后再开始计时，等待1秒)。 + // 也就是说这个代码钟的效果看到的是：4秒执行一次。 （计算方式：每次执行3秒，间隔时间1秒，执行完以后再等待1秒，所以是 3+1） + threadPoolExecutor.scheduleWithFixedDelay(new Runnable() { + @Override + public void run() { + try { + Thread.sleep(3000L); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("任务-2 被执行，现在时间：" + System.currentTimeMillis()); + } + }, 2000, 1000, TimeUnit.MILLISECONDS); + } + + /** + * 7、 终止线程：线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的 + * + * @throws Exception + */ + private void threadPoolExecutorTest7() throws Exception { + // 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。 + // 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy + ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, + new LinkedBlockingQueue(3), new RejectedExecutionHandler() { + @Override + public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { + System.err.println("有任务被拒绝执行了"); + } + }); + // 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况 + for (int i = 0; i < 15; i++) { + int n = i; + threadPoolExecutor.submit(new Runnable() { + @Override + public void run() { + try { + System.out.println("开始执行：" + n); + Thread.sleep(3000L); + System.err.println("执行结束:" + n); + } catch (InterruptedException e) { + System.out.println("异常：" + e.getMessage()); + } + } + }); + System.out.println("任务提交成功 :" + i); + } + // 1秒后终止线程池 + Thread.sleep(1000L); + threadPoolExecutor.shutdown(); + // 再次提交提示失败 + threadPoolExecutor.submit(new Runnable() { + @Override + public void run() { + System.out.println("追加一个任务"); + } + }); + // 结果分析 + // 1、 10个任务被执行，3个任务进入队列等待，2个任务被拒绝执行 + // 2、调用shutdown后，不接收新的任务，等待13任务执行结束 + // 3、 追加的任务在线程池关闭后，无法再提交，会被拒绝执行 + } + + /** + * 8、 立刻终止线程：线程池信息： 核心线程数量5，最大数量10，队列大小3，超出核心线程数量的线程存活时间：5秒， 指定拒绝策略的 + * + * @throws Exception + */ + private void threadPoolExecutorTest8() throws Exception { + // 创建一个 核心线程数量为5，最大数量为10,等待队列最大是3 的线程池，也就是最大容纳13个任务。 + // 默认的策略是抛出RejectedExecutionException异常，java.util.concurrent.ThreadPoolExecutor.AbortPolicy + ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS, + new LinkedBlockingQueue(3), new RejectedExecutionHandler() { + @Override + public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { + System.err.println("有任务被拒绝执行了"); + } + }); + // 测试： 提交15个执行时间需要3秒的任务，看超过大小的2个，对应的处理情况 + for (int i = 0; i < 15; i++) { + int n = i; + threadPoolExecutor.submit(new Runnable() { + @Override + public void run() { + try { + System.out.println("开始执行：" + n); + Thread.sleep(3000L); + System.err.println("执行结束:" + n); + } catch (InterruptedException e) { + System.out.println("异常：" + e.getMessage()); + } + } + }); + System.out.println("任务提交成功 :" + i); + } + // 1秒后终止线程池 + Thread.sleep(1000L); + List shutdownNow = threadPoolExecutor.shutdownNow(); + // 再次提交提示失败 + threadPoolExecutor.submit(new Runnable() { + @Override + public void run() { + System.out.println("追加一个任务"); + } + }); + System.out.println("未结束的任务有：" + shutdownNow.size()); + + // 结果分析 + // 1、 10个任务被执行，3个任务进入队列等待，2个任务被拒绝执行 + // 2、调用shutdownnow后，队列中的3个线程不再执行，10个线程被终止 + // 3、 追加的任务在线程池关闭后，无法再提交，会被拒绝执行 + } +} diff --git a/concurrency/src/main/java/workerthread/v1/Channel.java b/concurrency/src/main/java/workerthread/v1/Channel.java new file mode 100644 index 0000000..74b105f --- /dev/null +++ b/concurrency/src/main/java/workerthread/v1/Channel.java @@ -0,0 +1,87 @@ +package workerthread.v1; + +/** + * 传递工作请求及保存工作线程 + * + * @author JavaEdge + */ +public class Channel { + private static final int MAX_REQUEST = 100; + + /** + * 请求的队列 + */ + private final Request[] requestQueue; + + /** + * 下次 putReq 的位置 + */ + private int tail; + + /** + * 下次 takeReq 的位置 + */ + private int head; + + /** + * Req 的数量 + */ + private int count; + + private final WorkerThread[] threadPool; + + public Channel(int threads) { + this.requestQueue = new Request[MAX_REQUEST]; + this.head = 0; + this.tail = 0; + this.count = 0; + + threadPool = new WorkerThread[threads]; + for (int i = 0; i < threadPool.length; i++) { + threadPool[i] = new WorkerThread("Worker-" + i, this); + } + } + + public void startWorkers() { + for (int i = 0; i < threadPool.length; i++) { + threadPool[i].start(); + } + } + + /** + * 将请求放入队列 + * + * @param request + */ + public synchronized void putRequest(Request request) { + while (count >= requestQueue.length) { + try { + wait(); + } catch (InterruptedException e) { + } + } + requestQueue[tail] = request; + tail = (tail + 1) % requestQueue.length; + count++; + notifyAll(); + } + + /** + * 取出队列中的请求 + * + * @return + */ + public synchronized Request takeRequest() { + while (count <= 0) { + try { + wait(); + } catch (InterruptedException e) { + } + } + Request request = requestQueue[head]; + head = (head + 1) % requestQueue.length; + count--; + notifyAll(); + return request; + } +} diff --git a/concurrency/src/main/java/workerthread/v1/ClientThread.java b/concurrency/src/main/java/workerthread/v1/ClientThread.java new file mode 100644 index 0000000..7319fda --- /dev/null +++ b/concurrency/src/main/java/workerthread/v1/ClientThread.java @@ -0,0 +1,33 @@ +package workerthread.v1; + +import java.util.Random; + +/** + * 发送工作请求 + * + * @author JavaEdge + */ +public class ClientThread extends Thread { + private final Channel channel; + + private static final Random random = new Random(); + + public ClientThread(String name, Channel channel) { + super(name); + this.channel = channel; + } + + @Override + public void run() { + for (int i = 0; true; i++) { + // 创建请求实例 + Request request = new Request(getName(), i); + channel.putRequest(request); + try { + Thread.sleep(random.nextInt(1000)); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } +} diff --git a/concurrency/src/main/java/workerthread/v1/Main.java b/concurrency/src/main/java/workerthread/v1/Main.java new file mode 100644 index 0000000..ee4b8ef --- /dev/null +++ b/concurrency/src/main/java/workerthread/v1/Main.java @@ -0,0 +1,22 @@ +package workerthread.v1; + + +/** + * @author JavaEdge + */ +public class Main { + public static void main(String[] args) { + // 工作线程的个数 + Channel channel = new Channel(5); + channel.startWorkers(); + new ClientThread("Alice", channel).start(); + new ClientThread("Bobby", channel).start(); + new ClientThread("Chris", channel).start(); + + try { + Thread.sleep(30000); + } catch (InterruptedException e) { + } + System.exit(0); + } +} diff --git a/concurrency/src/main/java/workerthread/v1/Request.java b/concurrency/src/main/java/workerthread/v1/Request.java new file mode 100644 index 0000000..105d4ae --- /dev/null +++ b/concurrency/src/main/java/workerthread/v1/Request.java @@ -0,0 +1,36 @@ +package workerthread.v1; + +/** + * 工作请求 + * + * @author JavaEdge + */ +public class Request { + + /** + * 发送请求的委托人的名字 + */ + private final String name; + + /** + * 请求的编号 + */ + private final int number; + + public Request(String name, int number) { + this.name = name; + this.number = number; + } + + /** + * 处理请求 + */ + public void execute() { + System.out.println(Thread.currentThread().getName() + " executes " + this); + } + + @Override + public String toString() { + return "[ Request from " + name + " No." + number + " ]"; + } +} diff --git a/concurrency/src/main/java/workerthread/v1/WorkerThread.java b/concurrency/src/main/java/workerthread/v1/WorkerThread.java new file mode 100644 index 0000000..ca952e8 --- /dev/null +++ b/concurrency/src/main/java/workerthread/v1/WorkerThread.java @@ -0,0 +1,26 @@ +package workerthread.v1; + +/** + * 工作线程 + * + * @author JavaEdge + */ +public class WorkerThread extends Thread { + + private final Channel channel; + + public WorkerThread(String name, Channel channel) { + super(name); + this.channel = channel; + } + + @Override + public void run() { + while (true) { + // 获得一个 Req 实例 + Request request = channel.takeRequest(); + // 执行之 + request.execute(); + } + } +} diff --git a/concurrency/src/main/java/workerthread/v2/Channel.java b/concurrency/src/main/java/workerthread/v2/Channel.java new file mode 100644 index 0000000..e8fe85f --- /dev/null +++ b/concurrency/src/main/java/workerthread/v2/Channel.java @@ -0,0 +1,19 @@ +package workerthread.v2; + +import workerthread.v1.Request; + +public final class Channel { + public Channel(int threads) { + } + + public void startWorkers() { + } + + public void putRequest(final Request request) { + new Thread() { + public void run() { + request.execute(); + } + }.start(); + } +} diff --git a/concurrency/src/main/main.iml b/concurrency/src/main/main.iml new file mode 100644 index 0000000..6e2ebbf --- /dev/null +++ b/concurrency/src/main/main.iml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/concurrency/src/main/resources/application.properties b/concurrency/src/main/resources/application.properties new file mode 100644 index 0000000..c628fd1 --- /dev/null +++ b/concurrency/src/main/resources/application.properties @@ -0,0 +1,4 @@ +# redis conf +jedis.host=127.0.0.1 +jedis.port=6379 + diff --git a/concurrency/src/test/java/com/javaedge/concurrency/ConcurrencyApplicationTests.java b/concurrency/src/test/java/com/javaedge/concurrency/ConcurrencyApplicationTests.java new file mode 100755 index 0000000..ccd5c26 --- /dev/null +++ b/concurrency/src/test/java/com/javaedge/concurrency/ConcurrencyApplicationTests.java @@ -0,0 +1,16 @@ +package com.javaedge.concurrency; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.junit4.SpringRunner; + +@RunWith(SpringRunner.class) +@SpringBootTest +public class ConcurrencyApplicationTests { + + @Test + public void contextLoads() { + } + +} diff --git a/concurrency/src/test/test.iml b/concurrency/src/test/test.iml new file mode 100644 index 0000000..a0e49a3 --- /dev/null +++ b/concurrency/src/test/test.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/license.txt b/license.txt new file mode 100644 index 0000000..686ea8f --- /dev/null +++ b/license.txt @@ -0,0 +1,22 @@ + +The MIT License (MIT) + +Copyright (c) 2013-present, shusheng shi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/mvnw b/mvnw new file mode 100755 index 0000000..df68171 --- /dev/null +++ b/mvnw @@ -0,0 +1,225 @@ +#!/bin/sh +# ---------------------------------------------------------------------------- +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# ---------------------------------------------------------------------------- + +# ---------------------------------------------------------------------------- +# Maven2 Start Up Batch script +# +# Required ENV vars: +# ------------------ +# JAVA_HOME - location of a JDK home dir +# +# Optional ENV vars +# ----------------- +# M2_HOME - location of maven2's installed home dir +# MAVEN_OPTS - parameters passed to the Java VM when running Maven +# e.g. to debug Maven itself, use +# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 +# MAVEN_SKIP_RC - flag to disable loading of mavenrc files +# ---------------------------------------------------------------------------- + +if [ -z "$MAVEN_SKIP_RC" ] ; then + + if [ -f /etc/mavenrc ] ; then + . /etc/mavenrc + fi + + if [ -f "$HOME/.mavenrc" ] ; then + . "$HOME/.mavenrc" + fi + +fi + +# OS specific support. $var _must_ be set to either true or false. +cygwin=false; +darwin=false; +mingw=false +case "`uname`" in + CYGWIN*) cygwin=true ;; + MINGW*) mingw=true;; + Darwin*) darwin=true + # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home + # See https://developer.JavaEdge.com/library/mac/qa/qa1170/_index.html + if [ -z "$JAVA_HOME" ]; then + if [ -x "/usr/libexec/java_home" ]; then + export JAVA_HOME="`/usr/libexec/java_home`" + else + export JAVA_HOME="/Library/Java/Home" + fi + fi + ;; +esac + +if [ -z "$JAVA_HOME" ] ; then + if [ -r /etc/gentoo-release ] ; then + JAVA_HOME=`java-config --jre-home` + fi +fi + +if [ -z "$M2_HOME" ] ; then + ## resolve links - $0 may be a link to maven's home + PRG="$0" + + # need this for relative symlinks + while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG="`dirname "$PRG"`/$link" + fi + done + + saveddir=`pwd` + + M2_HOME=`dirname "$PRG"`/.. + + # make it fully qualified + M2_HOME=`cd "$M2_HOME" && pwd` + + cd "$saveddir" + # echo Using m2 at $M2_HOME +fi + +# For Cygwin, ensure paths are in UNIX format before anything is touched +if $cygwin ; then + [ -n "$M2_HOME" ] && + M2_HOME=`cygpath --unix "$M2_HOME"` + [ -n "$JAVA_HOME" ] && + JAVA_HOME=`cygpath --unix "$JAVA_HOME"` + [ -n "$CLASSPATH" ] && + CLASSPATH=`cygpath --path --unix "$CLASSPATH"` +fi + +# For Migwn, ensure paths are in UNIX format before anything is touched +if $mingw ; then + [ -n "$M2_HOME" ] && + M2_HOME="`(cd "$M2_HOME"; pwd)`" + [ -n "$JAVA_HOME" ] && + JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`" + # TODO classpath? +fi + +if [ -z "$JAVA_HOME" ]; then + javaExecutable="`which javac`" + if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then + # readlink(1) is not available as standard on Solaris 10. + readLink=`which readlink` + if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then + if $darwin ; then + javaHome="`dirname \"$javaExecutable\"`" + javaExecutable="`cd \"$javaHome\" && pwd -P`/javac" + else + javaExecutable="`readlink -f \"$javaExecutable\"`" + fi + javaHome="`dirname \"$javaExecutable\"`" + javaHome=`expr "$javaHome" : '\(.*\)/bin'` + JAVA_HOME="$javaHome" + export JAVA_HOME + fi + fi +fi + +if [ -z "$JAVACMD" ] ; then + if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + else + JAVACMD="`which java`" + fi +fi + +if [ ! -x "$JAVACMD" ] ; then + echo "Error: JAVA_HOME is not defined correctly." >&2 + echo " We cannot execute $JAVACMD" >&2 + exit 1 +fi + +if [ -z "$JAVA_HOME" ] ; then + echo "Warning: JAVA_HOME environment variable is not set." +fi + +CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher + +# traverses directory structure from process work directory to filesystem root +# first directory with .mvn subdirectory is considered project base directory +find_maven_basedir() { + + if [ -z "$1" ] + then + echo "Path not specified to find_maven_basedir" + return 1 + fi + + basedir="$1" + wdir="$1" + while [ "$wdir" != '/' ] ; do + if [ -d "$wdir"/.mvn ] ; then + basedir=$wdir + break + fi + # workaround for JBEAP-8937 (on Solaris 10/Sparc) + if [ -d "${wdir}" ]; then + wdir=`cd "$wdir/.."; pwd` + fi + # end of workaround + done + echo "${basedir}" +} + +# concatenates all lines of a file +concat_lines() { + if [ -f "$1" ]; then + echo "$(tr -s '\n' ' ' < "$1")" + fi +} + +BASE_DIR=`find_maven_basedir "$(pwd)"` +if [ -z "$BASE_DIR" ]; then + exit 1; +fi + +export MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"} +echo $MAVEN_PROJECTBASEDIR +MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS" + +# For Cygwin, switch paths to Windows format before running java +if $cygwin; then + [ -n "$M2_HOME" ] && + M2_HOME=`cygpath --path --windows "$M2_HOME"` + [ -n "$JAVA_HOME" ] && + JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"` + [ -n "$CLASSPATH" ] && + CLASSPATH=`cygpath --path --windows "$CLASSPATH"` + [ -n "$MAVEN_PROJECTBASEDIR" ] && + MAVEN_PROJECTBASEDIR=`cygpath --path --windows "$MAVEN_PROJECTBASEDIR"` +fi + +WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain + +exec "$JAVACMD" \ + $MAVEN_OPTS \ + -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \ + "-Dmaven.home=${M2_HOME}" "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \ + ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@" diff --git a/mvnw.cmd b/mvnw.cmd new file mode 100755 index 0000000..019bd74 --- /dev/null +++ b/mvnw.cmd @@ -0,0 +1,143 @@ +@REM ---------------------------------------------------------------------------- +@REM Licensed to the Apache Software Foundation (ASF) under one +@REM or more contributor license agreements. See the NOTICE file +@REM distributed with this work for additional information +@REM regarding copyright ownership. The ASF licenses this file +@REM to you under the Apache License, Version 2.0 (the +@REM "License"); you may not use this file except in compliance +@REM with the License. You may obtain a copy of the License at +@REM +@REM http://www.apache.org/licenses/LICENSE-2.0 +@REM +@REM Unless required by applicable law or agreed to in writing, +@REM software distributed under the License is distributed on an +@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +@REM KIND, either express or implied. See the License for the +@REM specific language governing permissions and limitations +@REM under the License. +@REM ---------------------------------------------------------------------------- + +@REM ---------------------------------------------------------------------------- +@REM Maven2 Start Up Batch script +@REM +@REM Required ENV vars: +@REM JAVA_HOME - location of a JDK home dir +@REM +@REM Optional ENV vars +@REM M2_HOME - location of maven2's installed home dir +@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands +@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a key stroke before ending +@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven +@REM e.g. to debug Maven itself, use +@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 +@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files +@REM ---------------------------------------------------------------------------- + +@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on' +@echo off +@REM enable echoing my setting MAVEN_BATCH_ECHO to 'on' +@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO% + +@REM set %HOME% to equivalent of $HOME +if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%") + +@REM Execute a user defined script before this one +if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre +@REM check for pre script, once with legacy .bat ending and once with .cmd ending +if exist "%HOME%\mavenrc_pre.bat" call "%HOME%\mavenrc_pre.bat" +if exist "%HOME%\mavenrc_pre.cmd" call "%HOME%\mavenrc_pre.cmd" +:skipRcPre + +@setlocal + +set ERROR_CODE=0 + +@REM To isolate internal variables from possible post scripts, we use another setlocal +@setlocal + +@REM ==== START VALIDATION ==== +if not "%JAVA_HOME%" == "" goto OkJHome + +echo. +echo Error: JAVA_HOME not found in your environment. >&2 +echo Please set the JAVA_HOME variable in your environment to match the >&2 +echo location of your Java installation. >&2 +echo. +goto error + +:OkJHome +if exist "%JAVA_HOME%\bin\java.exe" goto init + +echo. +echo Error: JAVA_HOME is set to an invalid directory. >&2 +echo JAVA_HOME = "%JAVA_HOME%" >&2 +echo Please set the JAVA_HOME variable in your environment to match the >&2 +echo location of your Java installation. >&2 +echo. +goto error + +@REM ==== END VALIDATION ==== + +:init + +@REM Find the project base dir, i.e. the directory that contains the folder ".mvn". +@REM Fallback to current working directory if not found. + +set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR% +IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir + +set EXEC_DIR=%CD% +set WDIR=%EXEC_DIR% +:findBaseDir +IF EXIST "%WDIR%"\.mvn goto baseDirFound +cd .. +IF "%WDIR%"=="%CD%" goto baseDirNotFound +set WDIR=%CD% +goto findBaseDir + +:baseDirFound +set MAVEN_PROJECTBASEDIR=%WDIR% +cd "%EXEC_DIR%" +goto endDetectBaseDir + +:baseDirNotFound +set MAVEN_PROJECTBASEDIR=%EXEC_DIR% +cd "%EXEC_DIR%" + +:endDetectBaseDir + +IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig + +@setlocal EnableExtensions EnableDelayedExpansion +for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a +@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS% + +:endReadAdditionalConfig + +SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe" + +set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar" +set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain + +%MAVEN_JAVA_EXE% %JVM_CONFIG_MAVEN_PROPS% %MAVEN_OPTS% %MAVEN_DEBUG_OPTS% -classpath %WRAPPER_JAR% "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %* +if ERRORLEVEL 1 goto error +goto end + +:error +set ERROR_CODE=1 + +:end +@endlocal & set ERROR_CODE=%ERROR_CODE% + +if not "%MAVEN_SKIP_RC%" == "" goto skipRcPost +@REM check for post script, once with legacy .bat ending and once with .cmd ending +if exist "%HOME%\mavenrc_post.bat" call "%HOME%\mavenrc_post.bat" +if exist "%HOME%\mavenrc_post.cmd" call "%HOME%\mavenrc_post.cmd" +:skipRcPost + +@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on' +if "%MAVEN_BATCH_PAUSE%" == "on" pause + +if "%MAVEN_TERMINATE_CMD%" == "on" exit %ERROR_CODE% + +exit /B %ERROR_CODE% diff --git a/pom.xml b/pom.xml new file mode 100755 index 0000000..19c29f6 --- /dev/null +++ b/pom.xml @@ -0,0 +1,118 @@ + + + 4.0.0 + + com.javaedge + concurrency + 0.0.1-SNAPSHOT + + concurrency + Demo project for Spring Boot + + + org.springframework.boot + spring-boot-starter-parent + 1.5.9.RELEASE + + + + + UTF-8 + UTF-8 + 1.8 + com.javaedge.concurrency.ConcurrencyApplication + + + + + + org.springframework.boot + spring-boot-starter-web + + + + org.springframework.boot + spring-boot-starter-test + test + + + + com.google.guava + guava + 23.0 + + + + joda-time + joda-time + 2.9 + + + + redis.clients + jedis + 2.8.2 + + + + org.springframework.kafka + spring-kafka + 2.1.5.RELEASE + + + + com.google.code.gson + gson + 2.8.5 + + + + com.rabbitmq + amqp-client + 5.6.0 + + + + org.springframework.amqp + spring-rabbit + 2.1.4.RELEASE + + + org.springframework.boot + spring-boot-test + + + org.testng + testng + 7.0.0-beta3 + compile + + + + org.projectlombok + lombok + + + junit + junit + + + + io.netty + netty-all + 4.1.15.Final + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + + + +

Bp1T~@8njNiL}ka0|f-AgN~q~ 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