java code

weilongzhao · weilongzhao · commit eda37b38f2ec · 2021-07-15T22:28:38.000+08:00
diff --git a/BlockQueueDemo.java b/BlockQueueDemo.java
@@ -0,0 +1,20 @@
+package edu.nwpu.zhao.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+
+public class BlockQueueDemo {
+    public static void main(String[] args) {
+        BlockingQueue blockingQueue = new ArrayBlockingQueue(3);
+
+        System.out.println(blockingQueue.offer("a"));
+        System.out.println(blockingQueue.offer("a"));
+        System.out.println(blockingQueue.offer("a"));
+        System.out.println("====================");
+        System.out.println(blockingQueue.element());
+        System.out.println(blockingQueue.offer("a"));
+
+
+    }
+
+}
diff --git a/CallableDemo.java b/CallableDemo.java
@@ -0,0 +1,27 @@
+package edu.nwpu.zhao.Test;
+
+import java.util.concurrent.*;
+
+/**
+ * @author:weilongzhao
+ * @time:2021/7/15 16:22
+ *
+ * 多线程已经有extants Thread 和Runnable 接口，为什么需要Callable 接口
+ */
+class MyThread implements Callable<Integer>{
+
+    @Override
+    public Integer call() throws Exception {
+        System.out.println(Thread.currentThread().getName()+" come in");
+        TimeUnit.SECONDS.sleep(2);
+        return 1024;
+    }
+}
+public class CallableDemo {
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread());
+        new Thread(futureTask,"AA").start();
+        System.out.println(Thread.currentThread().getName()+" come in");
+        System.out.println(futureTask.get()+100);
+    }
+}
diff --git a/CountDownLatchDemo.java b/CountDownLatchDemo.java
@@ -0,0 +1,21 @@
+package edu.nwpu.zhao.Test;
+
+import java.util.concurrent.CountDownLatch;
+
+public class CountDownLatchDemo {
+    //前五个线程做完后，主线程才能执行
+    //如何保证是期望的线程完成后，（cpu存在很多其它线程），因为在对应的线程结束后调用cdl.countDown();
+    //主线程上没有写cdl.await() 会发生什么?->主线程可能先实行
+    public static void main(String[] args) throws InterruptedException {
+        CountDownLatch cdl = new CountDownLatch(5);
+        for(int i = 0;i<5;i++){
+            final int tmpInt = i;
+            new Thread(()->{
+                System.out.println(tmpInt+"is over");
+                cdl.countDown();
+            },String.valueOf(i)).start();
+        }
+        cdl.await();
+        System.out.println("all is over");
+    }
+}
diff --git a/CyclicBarrierDemo.java b/CyclicBarrierDemo.java
@@ -0,0 +1,26 @@
+package edu.nwpu.zhao.Test;
+
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CyclicBarrier;
+
+class CyclicBarrierDemo {
+    public static void main(String[] args) {
+        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
+            System.out.println("now start");
+        });
+        for(int i = 0;i<7;i++){
+            final int tmpInt = i;
+            new Thread(()->{
+                System.out.println(tmpInt+"is over");
+                try {
+                    cyclicBarrier.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                } catch (BrokenBarrierException e) {
+                    e.printStackTrace();
+                }
+            },String.valueOf(i)).start();
+        }
+    }
+
+}
diff --git a/Leecode.java b/Leecode.java
@@ -0,0 +1,41 @@
+package edu.nwpu.zhao.Test;
+
+/**
+ * @author:weilongzhao
+ * @time:2021/7/15 21:38
+ */
+public class Leecode {
+    public static void main(String[] args) {
+        int[] arr = {1,7,3,6,5,6};
+        //System.out.println(arrayCenterIndex(arr));
+        int[] array = {0,1,2,2,3,3,3,4,4,4,4};
+        System.out.println(deleteDuplicatedElements(array));;
+    }
+
+    private static int arrayCenterIndex(int[] arr) {
+        int total = 0;
+        int sum = 0;
+        for(int i = 0;i<arr.length;i++){
+            sum += arr[i];
+        }
+        for(int i = 0;i<arr.length;i++){
+            total += arr[i];
+            if(total == sum){
+                return i;
+            }
+            sum -= arr[i];
+        }
+        return -1;
+    }
+    public static int deleteDuplicatedElements(int[] array){
+        int len = array.length;
+        int count = 1;
+        int j = 0;//慢游标
+        for (int i = 1;i<len;i++,j++){
+            if(array[i]!=array[j]){
+                count++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/ProConsumer_BlockQueueDemo.java b/ProConsumer_BlockQueueDemo.java
@@ -0,0 +1,68 @@
+package edu.nwpu.zhao.Test;
+
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * @author:weilongzhao
+ * @time:2021/7/13 18:57
+ */
+
+class ShareData{
+    private int number = 0;
+    private Lock lock = new ReentrantLock();
+    private Condition condition = lock.newCondition();
+    public void increasement(){
+        lock.lock();
+        try {
+            //判断
+            while(number!=0){
+                condition.await();
+            }
+            //干活
+            number++;
+            System.out.println(Thread.currentThread().getName()+"\t"+number);
+            //通知
+            condition.signalAll();
+        }catch (InterruptedException e){
+            e.printStackTrace();
+        }finally {
+            lock.unlock();
+        }
+    }
+    public void decreasement(){
+        lock.lock();
+        try {
+            //判断
+            while(number==0){
+                condition.await();
+            }
+            //干活
+            number--;
+            System.out.println(Thread.currentThread().getName()+"\t"+number);
+            //通知
+            condition.signalAll();
+        }catch (InterruptedException e){
+            e.printStackTrace();
+        }finally {
+            lock.unlock();
+        }
+
+    }
+}
+public class ProConsumer_BlockQueueDemo {
+    public static void main(String[] args) {
+        ShareData shareData = new ShareData();
+        new Thread(()->{
+            for (int i = 0; i < 5; i++) {
+                shareData.increasement();
+            }
+        },"A").start();
+        new Thread(()->{
+            for (int i = 0; i < 5; i++) {
+                shareData.decreasement();
+            }
+        },"B").start();
+    }
+}
diff --git a/ReadWriteLockDemo.java b/ReadWriteLockDemo.java
@@ -0,0 +1,76 @@
+package edu.nwpu.zhao.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+public class ReadWriteLockDemo {
+    private Map map = new HashMap();
+    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
+
+    public void put(String key,Object value){
+        rwLock.writeLock().lock();
+        try {
+            System.out.println(Thread.currentThread().getName()+"\t is writing:"+key);
+            try{
+                TimeUnit.MILLISECONDS.sleep(300);
+            }catch (InterruptedException e){
+                e.printStackTrace();
+            }
+            map.put(key,value);
+            System.out.println(Thread.currentThread().getName()+"writing is over");
+        }catch (Exception e){
+            e.printStackTrace();
+        }finally {
+            rwLock.writeLock().unlock();
+        }
+    }
+    public void get(String key){
+        rwLock.readLock().lock();
+        try{
+            System.out.println(Thread.currentThread().getName()+"\t正在读取");
+            try{
+                TimeUnit.MILLISECONDS.sleep(300);
+            }catch (InterruptedException e){
+                e.printStackTrace();
+            }
+            Object result = map.get(key);
+            System.out.println(Thread.currentThread().getName()+"\t读取完成");
+        }catch (Exception e){
+            e.printStackTrace();
+        }finally {
+            rwLock.readLock().lock();
+        }
+    }
+
+    public void getWithoutLock(String key){
+        System.out.println(Thread.currentThread().getName()+"\tis reading");
+        try{
+            TimeUnit.MILLISECONDS.sleep(300);
+        }catch (InterruptedException e){
+            e.printStackTrace();
+        }
+        Object result = map.get(key);
+        System.out.println(Thread.currentThread().getName()+"\treading is over");
+    }
+
+    public static void main(String[] args) {
+        ReadWriteLockDemo rwLockDemo = new ReadWriteLockDemo();
+        for(int i = 0;i<5;i++){
+            final int tmpInt = i;
+            new Thread(()->{
+                rwLockDemo.put("" + tmpInt, tmpInt);
+            },String.valueOf(i)).start();
+        }
+        for(int i = 0;i<5;i++){
+            final int tmpInt = i;
+            //“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final
+            // 方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“
+            //对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象
+            new Thread(()->{
+                rwLockDemo.get(""+tmpInt);
+            },String.valueOf(i)).start();
+        }
+    }
+}
diff --git a/SemaphoreDemo.java b/SemaphoreDemo.java
@@ -0,0 +1,24 @@
+package edu.nwpu.zhao.Test;
+
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+
+public class SemaphoreDemo {
+    public static void main(String[] args) {
+        Semaphore semaphore = new Semaphore(3);
+        for(int i = 0;i<5;i++){
+            final int tmpInt = i;
+            new Thread(()->{
+                try {
+                    semaphore.acquire();
+                    System.out.println(tmpInt+"is in");
+                    TimeUnit.SECONDS.sleep(3);
+                    semaphore.release();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }).start();
+        }
+
+    }
+}
diff --git a/SingleInstanceDemo.java b/SingleInstanceDemo.java
@@ -0,0 +1,14 @@
+package edu.nwpu.zhao.Test;
+
+public class SingleInstanceDemo {
+    private static SingleInstanceDemo sInstance = null;
+    private SingleInstanceDemo (){
+        System.out.println("sInstance is created");
+    }
+    public synchronized static SingleInstanceDemo get(){
+        if (sInstance == null){
+            sInstance = new SingleInstanceDemo();
+        }
+        return sInstance;
+    }
+}
diff --git a/SpinLockDemo.java b/SpinLockDemo.java
@@ -0,0 +1,48 @@
+package edu.nwpu.zhao.Test;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class SpinLockDemo {
+    AtomicReference<Thread> atomicReference = new AtomicReference();
+    public void mylock(){
+        Thread thread = Thread.currentThread();
+        System.out.println(thread.getName()+"\t come in");
+        while(!atomicReference.compareAndSet(null,thread)){
+
+        }
+    }
+
+    public void myunlock(){
+        Thread thread = Thread.currentThread();
+        System.out.println(thread.getName()+"\t come out");
+        atomicReference.compareAndSet(thread,null);
+    }
+
+    public static void main(String[] args){
+        SpinLockDemo spinLockDemo = new SpinLockDemo();
+        new Thread(()->{
+            spinLockDemo.mylock();
+            try{
+                TimeUnit.SECONDS.sleep(5);
+            }catch (InterruptedException e){
+                e.printStackTrace();
+            }
+            spinLockDemo.myunlock();
+        },"AA").start();
+        try{
+            TimeUnit.SECONDS.sleep(1);
+        }catch (InterruptedException e){
+            e.printStackTrace();
+        }
+        new Thread(()->{
+            spinLockDemo.mylock();
+            try{
+                TimeUnit.SECONDS.sleep(1);
+            }catch (InterruptedException e){
+                e.printStackTrace();
+            }
+            spinLockDemo.myunlock();
+        },"BB").start();
+    }
+}
diff --git a/SychronousQueueDemo.java b/SychronousQueueDemo.java
diff --git a/TestMain.java b/TestMain.java
