Java的第一个坑，多线程入门

起因是一道笔试题：
http://edisonxu.org/2017/03/02/java-thread-communication.html#comments
(上面这篇文章中提到的关于volatile的答案似乎有问题)

几个坑的地方：
1. wait() 和notify() 一定是在synchronized()块中出现
　wait() 发生时会当前线程释放锁
　notify()发生时，会？
2. notify() 出现在wait() 之前则无效（和条件变量的区别）
3. Integer虽然可以调用wait(),notify(),但是由于赋新值时会改变对象，所以不能用在这里，要自己定义一个类似的东西

我的代码：

1，Ojbect，synchronized，wait，notify版

package mytest;

public class ThreadTest {
    static class ThreadNum{
        public int i;
        public ThreadNum(int value){
            i=value;
        }
    }
    private Object w1=new Object ();
    private Object w2=new Object();
    private Object o=new Object();
    private ThreadNum cur=new ThreadNum(1);//must use self-define type

    public Runnable newThreadOne() {
        return new Runnable() {
            public void run() {
                try {
                        for (int i = 0; i < 52; i=i+2) {
                            synchronized (cur) {//must inside synchronized block
                                if(cur.i==2)//从逻辑上来说，只有两个线程if应该没问题；但是有个叫Spurious wakeup 的东西要求这个地方一定要用while，然而懒得改了
                                {
                                    cur.wait();
                                }
                                System.out.print(i+1);
                                System.out.print(i+2);
                                cur.i=2;
                                cur.notify();
                            }
                    }
                } catch (InterruptedException e) {
                    System.out.println("Oops...");
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        return new Runnable() {
            public void run() {
                try {
                    for (int i = 0; i < 26; i++) {
                            synchronized (cur) {
                                if(cur.i==1)
                                {
                                    cur.wait();
                                }
                                System.out.print((char)('a'+i));
                                cur.i=1;
                                cur.notify();
                            }
                    }
                } catch (InterruptedException e) {
                    System.out.println("Oops...");
                }
            }
        };
    }

    public static void main(String args[]) throws InterruptedException {
        /*
        Object o=new Object();
        synchronized (o) {
            o.notify();
            System.out.println("notified");
            o.wait();
            System.out.println("wait");
        }*/

        ThreadTest test = new ThreadTest();
        Thread t1=new Thread(test.newThreadOne());
        Thread t2=new Thread(test.newThreadTwo());
        t1.start();
        t2.start();

    }
}

2.condition，lock，unlock，await，signal版

java的signal函数似乎一定是要持有锁的线程调用，这点和C的pthread_cond_t 不同

package mytest;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionTest {
    private Lock lock=new ReentrantLock(true);
    private Condition condition1=lock.newCondition();
    private Condition condition2=lock.newCondition();
    private int thread_to_run=1;
    public Runnable newThreadOne() {
        return new Runnable() {
            public void run() {
                try {
                        for (int i = 0; i < 52; i=i+2) {
                            synchronized (lock) {
                                while(thread_to_run!=1){
                                    condition1.wait();
                                }
                                System.out.print(i+1);
                                System.out.print(i+2);
                                condition2.signal();
                            }
                    }
                } catch (InterruptedException e) {
                    System.out.println("Oops...");
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        return new Runnable() {
            public void run() {
                try {
                    for (int i = 0; i < 26; i++) {
                            synchronized (lock) {
                                while(thread_to_run!=2){
                                    condition2.await();
                                }
                                System.out.print((char)('a'+i));
                                condition1.signal();
                            }
                    }
                } catch (InterruptedException e) {
                    System.out.println("Oops...");
                }
            }
        };
    }

    public static void main(String args[]) throws InterruptedException {
        /*
        Lock lock=new ReentrantLock(true);
        Condition condition1=lock.newCondition();
        condition1.signal();
        System.out.println("signal");
        lock.lock();
        System.out.println("before wait");
        condition1.await();
        System.out.println("wait");
        condition1.signal();
        System.out.println("signal");
        lock.unlock();
        */


        ThreadTest test = new ThreadTest();
        Thread t1=new Thread(test.newThreadOne());
        Thread t2=new Thread(test.newThreadTwo());
        t1.start();
        t2.start();
        t1.join();
        t2.join();

    }
}

3.信号量 semaphore，acquire，release

个人感觉信号量的版本最简单，因为这是一个关于顺序控制的问题，所以信号量会直接管理一个相关的计数器，不用像前面的程序那样需要自己控制另外一个变量

package mytest;

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    static class ThreadNum{
        public int i;
        public ThreadNum(int value){
            i=value;
        }
    }
    private Semaphore w1=new Semaphore(1);
    private Semaphore w2=new Semaphore(0);

    public Runnable newThreadOne() {
        return new Runnable() {
            public void run() {
                try {
                    for (int i = 0; i < 52; i=i+2) {
                        w1.acquire();
                        System.out.print(i+1);
                        System.out.print(i+2);
                        w2.release();
                    }
                } catch (InterruptedException e) {
                    System.out.println("Oops...");
                }
            }
        };
    }
    public Runnable newThreadTwo() {
        return new Runnable() {
            public void run() {
                try {
                    for (int i = 0; i < 26; i++) {
                        w2.acquire();
                        System.out.print((char)('a'+i));
                        w1.release();

                    }
                } catch (InterruptedException e) {
                    System.out.println("Oops...");
                }
            }
        };
    }

    public static void main(String args[]) throws InterruptedException {

        ThreadTest test = new ThreadTest();
        Thread t1=new Thread(test.newThreadOne());
        Thread t2=new Thread(test.newThreadTwo());

        t1.start();
        t2.start();
        t1.join();
        t2.join();

    }
}

参考：
1.异常
http://blog.csdn.net/historyasamirror/article/details/6709693
2.条件变量
http://blog.csdn.net/woshixuye/article/details/28283289
3.