add 代码示意

Author: lupingchn

java-knowledge-base/src/main/java/base/innerclass/ILog.java

@@ -0,0 +1,10 @@
+package base.innerclass;
+
+/**
+ * @author:zhangluping
+ * @description:
+ * @date:2019/6/3 9:25
+ */
+public interface ILog {
+    void write(String message);
+}

java-knowledge-base/src/main/java/base/innerclass/InnerClassDemo.java

@@ -0,0 +1,53 @@
+package base.innerclass;
+
+/**
+ * @author:zhangluping
+ * @description:
+ * @date:2019/6/3 9:24
+ */
+public class InnerClassDemo{
+    private int length =0;
+
+    private class InnerClass implements ILog {
+        @Override
+        public void write(String message) {
+            length = message.length();
+            System.out.println("DemoClass.InnerClass:" + length);
+        }
+    }
+
+    public ILog logger() {
+        return new InnerClass();
+    }
+
+
+    public ILog loggerAnonymity() {
+        return new ILog() {
+            @Override
+            public void write(String message) {
+                length = message.length();
+                System.out.println("DemoClass.InnerClass:" + length);
+            }
+        };
+    }
+
+    public ILog loggerLambda() {
+        return message -> {
+            length = message.length();
+            System.out.println("DemoClass.InnerClass:" + length);
+        };
+    }
+
+
+    public static void main(String[] args){
+        InnerClassDemo demoClass = new InnerClassDemo();
+        demoClass.logger().write("123");
+
+        //new
+        InnerClassDemo dc = new InnerClassDemo();
+        ILog ic = dc.loggerAnonymity();
+        ic.write("12345");
+
+        dc.loggerLambda().write("123456");
+    }
+}

java-knowledge-base/src/main/java/base/lambda/TestLambda.java

@@ -0,0 +1,33 @@
+package base.lambda;
+
+/**
+ * @author:zhangluping
+ * @description:
+ * @date:2019/6/3 20:23
+ */
+public class TestLambda {
+    /**
+     * lambda实现
+     */
+    private static void runThreadUseLambda() {
+        new Thread(() -> System.out.println("我是lambda实现的线程")).start();
+    }
+
+    /**
+     * 内部类实现
+     */
+    private static void runThreadUseInnerClass() {
+
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                System.out.println("内部类实现的线程");
+            }
+        }).start();
+    }
+
+    public static void main(String[] args) {
+        TestLambda.runThreadUseLambda();
+        TestLambda.runThreadUseInnerClass();
+    }
+}

java-knowledge-base/src/main/java/concurrent/java/cyclicbarrier/CyclicBarrierDemo.java

@@ -0,0 +1,27 @@
+package concurrent.java.cyclicbarrier;
+
+import java.util.concurrent.CyclicBarrier;
+
+/**
+ * @author:zhangluping
+ * @description:
+ * @date:2019/5/30 9:24
+ */
+public class CyclicBarrierDemo {
+    public static void main(String[] args) {
+        Runnable barrier1Action = () -> System.out.println("BarrierAction 1 executed ");
+        Runnable barrier2Action = () -> System.out.println("BarrierAction 2 executed ");
+
+        CyclicBarrier barrier1 = new CyclicBarrier(2, barrier1Action);
+        CyclicBarrier barrier2 = new CyclicBarrier(2, barrier2Action);
+
+        CyclicBarrierRunnable barrierRunnable1 =
+                new CyclicBarrierRunnable(barrier1, barrier2);
+
+        CyclicBarrierRunnable barrierRunnable2 =
+                new CyclicBarrierRunnable(barrier1, barrier2);
+
+        new Thread(barrierRunnable1).start();
+        new Thread(barrierRunnable2).start();
+    }
+}

java-knowledge-base/src/main/java/concurrent/java/cyclicbarrier/CyclicBarrierRunnable.java

@@ -0,0 +1,46 @@
+package concurrent.java.cyclicbarrier;
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+
+/**
+ * @author:zhangluping
+ * @description:
+ * @date:2019/5/30 9:23
+ */
+public class CyclicBarrierRunnable implements Runnable{
+
+    CyclicBarrier barrier1 = null;
+    CyclicBarrier barrier2 = null;
+
+    public CyclicBarrierRunnable(
+            CyclicBarrier barrier1,
+            CyclicBarrier barrier2) {
+
+        this.barrier1 = barrier1;
+        this.barrier2 = barrier2;
+    }
+
+    @Override
+    public void run() {
+        try {
+            Thread.sleep(1000);
+            System.out.println(Thread.currentThread().getName() +
+                    " waiting at barrier 1");
+            this.barrier1.await();
+
+            Thread.sleep(1000);
+            System.out.println(Thread.currentThread().getName() +
+                    " waiting at barrier 2");
+            this.barrier2.await();
+
+            System.out.println(Thread.currentThread().getName() +
+                    " done!");
+
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } catch (BrokenBarrierException e) {
+            e.printStackTrace();
+        }
+    }
+}

java-knowledge-base/src/main/java/concurrent/java/exchanger/ExchangerDemo.java

@@ -0,0 +1,58 @@
+package concurrent.java.exchanger;
+
+import java.util.concurrent.Exchanger;
+
+/**
+ * @author:zhangluping
+ * @description:
+ * @date:2019/5/30 9:28
+ */
+public class ExchangerDemo {
+    public static class ExchangerRunnable implements Runnable{
+
+        Exchanger exchanger = null;
+        Object    object    = null;
+
+        ExchangerRunnable(Exchanger exchanger, Object object) {
+            this.exchanger = exchanger;
+            this.object = object;
+        }
+
+        @Override
+        public void run() {
+            try {
+                Object previous = this.object;
+//                if(Thread.currentThread().getId() % 2 == 0) {
+                    this.object = this.exchanger.exchange(this.object);
+//                }
+                System.out.println(
+                        Thread.currentThread().getName() +
+                                " exchanged " + previous + " for " + this.object
+                );
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        Exchanger exchanger = new Exchanger();
+
+        ExchangerDemo.ExchangerRunnable exchangerRunnable1 =
+                new ExchangerDemo.ExchangerRunnable(exchanger, "A");
+
+        ExchangerDemo.ExchangerRunnable exchangerRunnable2 =
+                new ExchangerDemo.ExchangerRunnable(exchanger, "B");
+
+        ExchangerDemo.ExchangerRunnable exchangerRunnable3 =
+                new ExchangerDemo.ExchangerRunnable(exchanger, "C");
+
+        ExchangerDemo.ExchangerRunnable exchangerRunnable4 =
+                new ExchangerDemo.ExchangerRunnable(exchanger, "D");
+
+        new Thread(exchangerRunnable1).start();
+        new Thread(exchangerRunnable2).start();
+        new Thread(exchangerRunnable3).start();
+        new Thread(exchangerRunnable4).start();
+    }
+}

java-knowledge-base/src/main/java/concurrent/java/lock/ReadWriteLockDemo.java

@@ -0,0 +1,34 @@
+package concurrent.java.lock;
+
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * @author:zhangluping
+ * @description:
+ * @date:2019/5/30 12:39
+ */
+public class ReadWriteLockDemo {
+
+    public static void main(String[] args) {
+        ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+
+
+        readWriteLock.readLock().lock();
+
+        // multiple readers can enter this section
+        // if not locked for writing, and not writers waiting
+        // to lock for writing.
+
+        readWriteLock.readLock().unlock();
+
+
+        readWriteLock.writeLock().lock();
+
+        // only one writer can enter this section,
+        // and only if no threads are currently reading.
+
+        readWriteLock.writeLock().unlock();
+    }
+
+}