Lesson12 Concurrency

Tanechka · Tanechka · commit a34c2eec5a4b · 2017-08-24T10:44:28.000-07:00
diff --git a/src/ru/javawebinar/basejava/MainConcurrency.java b/src/ru/javawebinar/basejava/MainConcurrency.java
@@ -1,12 +1,32 @@
 package ru.javawebinar.basejava;
 
-import java.util.ArrayList;
-import java.util.List;
-
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * gkislin
+ * 29.08.2016
+ */
 public class MainConcurrency {
     public static final int THREADS_NUMBER = 10000;
     private int counter;
-    private static final Object LOCK = new Object();
+    private final AtomicInteger atomicCounter = new AtomicInteger();
+
+    //    private static final Object LOCK = new Object();
+//    private static final Lock lock = new ReentrantLock();
+    private static final ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
+    private static final Lock WRITE_LOCK = reentrantReadWriteLock.writeLock();
+    private static final Lock READ_LOCK = reentrantReadWriteLock.readLock();
+    private static final ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>() {
+        @Override
+        protected SimpleDateFormat initialValue() {
+            return new SimpleDateFormat();
+        }
+    };
 
     public static void main(String[] args) throws InterruptedException {
         System.out.println(Thread.currentThread().getName());
@@ -15,7 +35,7 @@ public static void main(String[] args) throws InterruptedException {
             @Override
             public void run() {
                 System.out.println(getName() + ", " + getState());
-                throw new IllegalStateException();
+//                throw new IllegalStateException();
             }
         };
         thread0.start();
@@ -38,32 +58,46 @@ private void inc() {
         System.out.println(thread0.getState());
 
         final MainConcurrency mainConcurrency = new MainConcurrency();
-        List<Thread> threads = new ArrayList<>(THREADS_NUMBER);
+        CountDownLatch latch = new CountDownLatch(THREADS_NUMBER);
+        ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+//        CompletionService completionService = new ExecutorCompletionService(executorService);
+//
+//        List<Thread> threads = new ArrayList<>(THREADS_NUMBER);
 
         for (int i = 0; i < THREADS_NUMBER; i++) {
-            Thread thread = new Thread(() -> {
+
+            Future<Integer> future = executorService.submit(() ->
+//            Thread thread = new Thread(() ->
+            {
                 for (int j = 0; j < 100; j++) {
                     mainConcurrency.inc();
+                    System.out.println(threadLocal.get().format(new Date()));
                 }
+                latch.countDown();
+                return 5;
             });
-            thread.start();
-            threads.add(thread);
+//            thread.start();
+//            threads.add(thread);
         }
 
+/*
         threads.forEach(t -> {
             try {
                 t.join();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         });
-        System.out.println(mainConcurrency.counter);
-
-        final String lock1 = "lock1";
-        final String lock2 = "lock2";
-        deadLock(lock1, lock2);
-        deadLock(lock2, lock1);
-
+*/
+        latch.await(10, TimeUnit.SECONDS);
+        executorService.shutdown();
+//        System.out.println(mainConcurrency.counter);
+        System.out.println(mainConcurrency.atomicCounter.get());
+
+//        final String lock1 = "lock1";
+//        final String lock2 = "lock2";
+//        deadLock(lock1, lock2);
+//        deadLock(lock2, lock1);
     }
 
     private static void deadLock(Object lock1, Object lock2) {
@@ -84,10 +118,16 @@ private static void deadLock(Object lock1, Object lock2) {
         }).start();
     }
 
-    private synchronized void inc() {
+    private void inc() {
 //        synchronized (this) {
 //        synchronized (MainConcurrency.class) {
-        counter++;
+//        WRITE_LOCK.lock();
+//        try {
+        atomicCounter.incrementAndGet();
+//            counter++;
+//        } finally {
+//            WRITE_LOCK.unlock();
+//        }
 //                wait();
 //                readFile
 //                ...
