java多线程

对原子性和可见性的理解

原子性：操作的完整性，要么全部执行完，要么不执行。
例如：count++;
这个其实是分为三个步骤完成的，“读改写”，在多线程环境下尤其要注意其同步问题，否则会造成脏数据等问题。
解决方法：可以通过atomic来保证变量的原子性。

可见性：一个写操作所做的修改，对于读数据来说是可见，具体的说就是读数据，读的是共享收据块里面的数据。
常见的实现手段有，volatile本地实现的写锁（即写操作的完整性，一次写入主存中，而非寄存器，或者缓存器中）但是volatile是不保证原子性的，当两个写线程同时发生，还是会造成脏数据问题。
volatile常用与标志变量的标记判断作用

volatile boolean shutdown;

public void openstatus(){
   shutdown = true;
}

public void shutstatus(){
   shutdown = false;
}

public dowork(){

   ServerSocket socket = new ServerSocket(80);
   Socket s = null;
   //shutdown变量控制socket阻塞读取状态
   while(!shutdown){
   s = socket.accept();
   //...
   }
}

---

Thead描述

一：Thread.yield

public static native void yield();

yield方法，意味着正在执行的线程，愿意放弃独占cpu，与具有相同优先级以及，更高级的线程共同竞争。

eg:

public class yieldtest {
    public static void main(String[] args) {
        producer p = new producer();
        consumer c = new consumer();
        //p.setPriority(Thread.MAX_PRIORITY);
        //c.setPriority(Thread.MAX_PRIORITY);
        p.start();
        c.start();
    }

    static class producer extends Thread{
        public void run(){
            for(int i=0;i<5;i++){
                System.out.println("this is producer"+i);
                Thread.yield();
            }
        }
    }

    static class consumer extends Thread{
        public void run(){
            for(int i=0;i<5;i++){
                System.out.println("this is consumer"+i);
                Thread.yield();
            }
        }
    }
}

二、 Thread.join()

    public final void join() throws InterruptedException {
        join(0);
    }

强调等当前线程执行完，才会执行下一个线程。可以设置定时（millis秒，nanos是纳秒），当超时后，所有线程是平等的，可以同步运行。

    public final synchronized void join(long millis, int nanos)
    throws InterruptedException {

未完待续。。。