no message

programTang · programTang · commit 545572f8bf61 · 2016-08-29T11:58:48.000+08:00
diff --git a/src/main/java/org/tj/study/enumtest/Weekday.java b/src/main/java/org/tj/study/enumtest/Weekday.java
@@ -3,5 +3,35 @@
 /**
  * Created by 001 on 16/8/22.
  */
-public class Weekday {
+public enum  Weekday {
+    Monday(1),Tuesday(2),Wednesday(3),Thuresday(4),Friday(5),Saturday(6),Sunday(7);
+    int value;
+
+    private Weekday(int value){
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return "Weekday{" +
+                "value=" + value +
+                '}';
+    }
 }
+
+class Test{
+    public static void main(String[] args) {
+        Weekday weekday = Weekday.valueOf("Wednesday");
+        System.out.println(weekday.getValue());
+
+        Weekday[] weekdays = Weekday.values();
+        for (Weekday weekday1:weekdays){
+
+        }
+
+    }
+}
diff --git a/src/main/java/org/tj/study/thread/abcd/join/DemoJoin.java b/src/main/java/org/tj/study/thread/abcd/join/DemoJoin.java
@@ -1,17 +1,21 @@
 package org.tj.study.thread.abcd.join;
 
+import java.util.concurrent.TimeUnit;
+
 /**
  * Created by 001 on 16/8/23.
  */
 public class DemoJoin implements Runnable{
 
+//    threadX.join  代表当前线程要等待X线程结束才能从join中返回继续执行
+
     Thread thread;
 
     public DemoJoin(Thread thread){
         this.thread = thread;
     }
 
-    public static void main(String[] args) {
+    public static void main(String[] args) throws InterruptedException {
         Thread thread1 = Thread.currentThread();
         Thread threadA = new Thread(new DemoJoin(thread1),"A");
         Thread threadB = new Thread(new DemoJoin(threadA),"B");
@@ -22,6 +26,8 @@ public static void main(String[] args) {
         threadB.start();
         threadC.start();
         threadD.start();
+        TimeUnit.SECONDS.sleep(5);
+        System.out.println(Thread.currentThread().getName() + " terminate.");
     }
 
     @Override
diff --git a/src/main/java/org/tj/study/thread/locks/DemoLock.java b/src/main/java/org/tj/study/thread/locks/DemoLock.java
@@ -1,7 +1,51 @@
 package org.tj.study.thread.locks;
 
+import sun.awt.Mutex;
+
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.AbstractQueuedSynchronizer;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 /**
  * Created by 001 on 16/8/24.
  */
-public class DemoLock {
+public class DemoLock implements Runnable{
+
+//    List<String> list = new ArrayList<>();
+    int i = 0;
+    Lock lock = new ReentrantLock();
+    @Override
+    public void run() {
+//        list.add("");
+//        lock.lock();
+//        synchronized (this){
+//            try {
+                i++;
+//            }finally {
+    //            lock.unlock();
+//            }
+//        }
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+        for (int j=0;j<20;j++){
+//            AbstractQueuedSynchronizer;
+//            Lock;
+//            ReentrantLock
+//            HashMap
+            DemoLock demoLock = new DemoLock();
+            Thread[] threads = new Thread[1000];
+            for (int i=0;i<1000;i++){
+                threads[i] = new Thread(demoLock);
+            }
+            for (int i=0;i<1000;i++){
+                threads[i].start();
+            }
+            Thread.sleep(1);
+            System.out.println(demoLock.i);
+        }
+
+    }
 }
diff --git a/src/main/java/org/tj/study/thread/locks/DemoReadWriterLock.java b/src/main/java/org/tj/study/thread/locks/DemoReadWriterLock.java
@@ -1,7 +1,49 @@
 package org.tj.study.thread.locks;
 
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
 /**
  * Created by 001 on 16/8/24.
  */
 public class DemoReadWriterLock {
+
+    static private Map<String,Object> map = new HashMap<>();
+    static private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+    static private Lock reader = readWriteLock.readLock();
+    static private Lock writer =readWriteLock.readLock();
+
+    static final Object get(String key){
+        reader.lock();
+        try {
+             return map.get(key);
+        }finally {
+            reader.unlock();
+        }
+    }
+
+    static final Object put(String key,Object object){
+        writer.lock();
+        try{
+            map.put(key,object);
+        }finally {
+            writer.unlock();
+        }
+        return object;
+    }
+
+    static void clear(){
+        writer.lock();
+        try {
+            map.clear();
+        }finally {
+            writer.unlock();
+        }
+    }
+
+
 }
diff --git a/src/main/java/org/tj/study/thread/locks/TestTwinsLock.java b/src/main/java/org/tj/study/thread/locks/TestTwinsLock.java
@@ -1,7 +1,48 @@
 package org.tj.study.thread.locks;
 
+import java.util.concurrent.locks.Lock;
+
 /**
  * Created by 001 on 16/8/24.
  */
 public class TestTwinsLock {
+
+    static Lock lock = new TwinsLock();
+
+
+    public TestTwinsLock(Lock lock) {
+        this.lock = lock;
+    }
+
+    public static void main(String[] args) throws InterruptedException {
+
+
+        class Worker implements Runnable{
+            @Override
+            public void run() {
+                while (true){
+                    lock.lock();
+                    try {
+                        Thread.sleep(1000);
+                        System.out.print(Thread.currentThread().getName() + "  ");
+                        Thread.sleep(1000);
+                        System.out.println();
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }finally {
+                        lock.unlock();
+                    }
+                }
+            }
+        }
+
+        for (int i = 0; i < 10; i++) {
+            new Thread(new Worker()).start();
+        }
+//// 每隔1秒换行
+//        for (int i = 0; i < 10; i++) {
+//            Thread.sleep(1000);
+//            System.out.println();
+//        }
+    }
 }
