udpate 0302

Author: kimmking

03concurrency/0301/src/main/java/java0/conc0302/atomic/AtomicCount.java

@@ -0,0 +1,17 @@
+
+package java0.conc0302.atomic;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class AtomicCount {
+
+    private AtomicInteger num = new AtomicInteger();
+
+    public synchronized int add() {
+        return num.getAndIncrement();
+    }
+
+    public int getNum() {
+        return num.get();
+    }
+}

03concurrency/0301/src/main/java/java0/conc0302/atomic/AtomicMain.java

@@ -0,0 +1,28 @@
+
+package java0.conc0302.atomic;
+
+public class AtomicMain {
+
+    public static void main(String[] args) {
+        final AtomicCount count = new AtomicCount();
+        for (int i = 0; i < 100; i++) {
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    for (int j = 0; j < 10000; j++) {
+                        count.add(); 
+                    }
+                }
+            }).start();
+        }
+
+        try {
+            Thread.sleep(1000L);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        System.out.println("num=" + count.getNum());
+    }
+
+}

03concurrency/0301/src/main/java/java0/conc0302/atomic/Count.java

@@ -0,0 +1,15 @@
+
+package java0.conc0302.atomic;
+
+public class Count {
+
+    private int num = 0;
+
+    public int add() {
+        return num++;
+    }
+
+    public int getNum() {
+        return num;
+    }
+}

03concurrency/0301/src/main/java/java0/conc0302/atomic/LongDemo.java

@@ -0,0 +1,35 @@
+package java0.conc0302.atomic;
+
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.LongAdder;
+
+public class LongDemo {
+    
+    public static void main(String[] args) {
+    
+        final AtomicLong atomicLong = new AtomicLong();
+        final LongAdder longAdder = new LongAdder();
+        
+        for (int i = 0; i < 100; i++) {
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    for (int j = 0; j < 10000; j++) {
+                        atomicLong.getAndIncrement();
+                        longAdder.increment();
+                    }
+                }
+            }).start();
+        }
+        
+        try {
+            Thread.sleep(1000L);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        
+        System.out.println("atomicLong=" + atomicLong.get());
+        System.out.println("longAdder =" + longAdder.sum());
+        
+    }
+}

03concurrency/0301/src/main/java/java0/conc0302/atomic/SyncCount.java

@@ -0,0 +1,15 @@
+
+package java0.conc0302.atomic;
+
+public class SyncCount {
+
+    private int num = 0;
+
+    public synchronized int add() {
+        return num++;
+    }
+
+    public int getNum() {
+        return num;
+    }
+}

03concurrency/0301/src/main/java/java0/conc0302/lock/ConditionDemo.java

@@ -0,0 +1,45 @@
+package java0.conc0302.lock;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+class ConditionDemo {
+    final Lock lock = new ReentrantLock();
+    final Condition notFull  = lock.newCondition();
+    final Condition notEmpty = lock.newCondition();
+    
+    final Object[] items = new Object[20];
+    int putptr, takeptr, count;
+    
+    public void put(Object x) throws InterruptedException {
+        lock.lock();
+        try {
+            // 当count等于数组的大小时，当前线程等待，直到notFull通知，再进行生产
+            while (count == items.length)
+                notFull.await();
+            items[putptr] = x;
+            if (++putptr == items.length) putptr = 0;
+            ++count;
+            notEmpty.signal();
+        } finally {
+            lock.unlock();
+        }
+    }
+    
+    public Object take() throws InterruptedException {
+        lock.lock();
+        try {
+            // 当count为0，进入等待，直到notEmpty通知，进行消费。
+            while (count == 0)
+                notEmpty.await();
+            Object x = items[takeptr];
+            if (++takeptr == items.length) takeptr = 0;
+            --count;
+            notFull.signal();
+            return x;
+        } finally {
+            lock.unlock();
+        }
+    }
+}

03concurrency/0301/src/main/java/java0/conc0302/lock/LockSupportDemo.java

@@ -0,0 +1,37 @@
+package java0.conc0302.lock;
+
+import java.util.concurrent.locks.LockSupport;
+
+public class LockSupportDemo {
+    
+    public static Object u = new Object();
+    static ChangeObjectThread t1 = new ChangeObjectThread("t1");
+    static ChangeObjectThread t2 = new ChangeObjectThread("t2");
+    
+    public static class ChangeObjectThread extends Thread {
+        public ChangeObjectThread(String name) {
+            super(name);
+        }
+        @Override public void run() {
+            synchronized (u) {
+                System.out.println("in " + getName());
+                LockSupport.park();
+                if (Thread.currentThread().isInterrupted()) {
+                    System.out.println("被中断了");
+                }
+                System.out.println("继续执行");
+            }
+        }
+    }
+    
+    public static void main(String[] args) throws InterruptedException {
+        t1.start();
+        Thread.sleep(1000L);
+        t2.start();
+        Thread.sleep(3000L);
+        t1.interrupt();
+        LockSupport.unpark(t2);
+        t1.join();
+        t2.join();
+    }
+}