java并发编程基础---Sky

1.线程及启动和终止

1.1 线程 -进程/优先级

操作系统调度的最小单元是线程，线程是轻量级进程。

线程优先级由setPriority(int)方法来设置，默认优先级是5，等级1~10.等级越高分的时间片越多。

1.2 线程的状态

new 初始化》》Runable 运行》》Blocked阻塞》》Wating等待》》 time_Wating超时等待》》 temerinated终止状态。

1.3 Daemon辅助线程

主线程终止后，辅助线程也就结束。thread.setDaemon(true)设置在线程开始之前。

1.4 过期suspend() , resume(), stop()为啥不建议使用？

suspend()调用后太霸道，不释放占有资源，而是抱着占有资源去睡觉，这样容易死锁。站着茅坑不拉屎。

resume()、stop()不保证线程资源正常释放，那要你们何用？

安全的终止线程：有中断操作，和自定义cancel（）方法。

 package Thread;

 import java.util.concurrent.TimeUnit;

 /**

  * Created by Sky on 2016/9/22.

  * @author xiaoyongyong

  */

 public class Shutdown {

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

         Runner one = new Runner();

         Thread countThread = new Thread(one,"CountThread");

         countThread.start();

         TimeUnit.SECONDS.sleep(1);

         countThread.interrupt();

         Runner two = new Runner();

         countThread = new Thread(two,"CountThread");

         countThread.start();

         TimeUnit.SECONDS.sleep(1);

         two.cancle();

     }

     private static class Runner  implements Runnable{

         private  long i;

         private volatile boolean on =true;

         @Override

         public void run() {

             while (on && !Thread.currentThread().isInterrupted()){

                 i++;

             }

             System.out.println("Count i ="+ i);

         }

         public void cancle(){

             on = false;

         }

     }

 }

2. 线程之间通信

2.1 volatile 和 synchronized 关键字。

volatile：它能保证所有线程对变量访问的可见性，即某线程对定义变量的修改，其他线程可见。谨慎使用，过多使用会降低程序运行效率。

syncchronized：保证只有一个线程能对其定义的变量修改。保证其变量访问的可见性和排他性。

2.2 通知/等待机制

可以确保及时性和降低开销。

相关方法：notify()、nitifyAll()、wait()、wait(long)、wait(long,int)。

注意点：1）使用notify()、nitifyAll()、wait()时需要先对调用对象加锁。2）notify()、nitifyAll()方法调用后，等待线程依旧不会从wait()方法返回，

需要调用notify()、nitifyAll()方法的线程，释放锁之后，等待线程才有机会从wait()返回。等待队列-》同步队列。3）wait()方法返回的前提是获取对象锁。

这种机制可以运用在生产者-消费者模式中。

 package Thread;

 import java.text.SimpleDateFormat;

 import java.util.Date;

 import java.util.concurrent.TimeUnit;

 /**

  * Created by Sky on 2016/9/22.

  *

  * @author xiaoyongyong

  */

 public class WaitNotify {

     static boolean flag = true;

     static final Object lock = new Object();

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

         Thread waitTread = new Thread(new Wait(), "WaitTread");

         waitTread.start();

         TimeUnit.SECONDS.sleep(1);

         Thread notifyTread = new Thread(new NotifyTread(), "NotifyTread");

         notifyTread.start();

     }

     private static class Wait implements Runnable {

         @Override

         public void run() {

             synchronized (lock) {

                 while (flag) {

                     try {

                         System.out.println(Thread.currentThread() + " flag is true.wait. " + new SimpleDateFormat("HH:mm:ss").format(new Date()));

                         lock.wait();

                     } catch (InterruptedException e) {

                         e.printStackTrace();

                     }

                 }

                 System.out.println(Thread.currentThread() + " flag is true.running. " + new SimpleDateFormat("HH:mm:ss").format(new Date()));

             }

         }

     }

     private static class NotifyTread  implements Runnable {

         @Override

         public void run() {

             synchronized (lock){

                 System.out.println(Thread.currentThread() + " hold lock.notify. " + new SimpleDateFormat("HH:mm:ss").format(new Date()));

                 lock.notifyAll();

                 flag = false;

                 try {

                     TimeUnit.SECONDS.sleep(2);

                 } catch (InterruptedException e) {

                     e.printStackTrace();

                 }

             }

             synchronized (lock) {

                 System.out.println(Thread.currentThread() + " hold lock.again.sleep " + new SimpleDateFormat("HH:mm:ss").format(new Date()));

                 try {

                     TimeUnit.SECONDS.sleep(2);

                 } catch (InterruptedException e) {

                     e.printStackTrace();

                 }

             }

         }

     }

 }

返回结果：

Thread[WaitTread,5,main] flag is true.wait. 22:03:45
Thread[NotifyTread,5,main] hold lock.notify. 22:03:46
Thread[NotifyTread,5,main] hold lock.again.sleep 22:03:48
Thread[WaitTread,5,main] flag is true.running. 22:03:50

2.3 管道输入/输出流

主要用于线程之间的数据传输，传输媒介是内存，有PipedOutputStream/PipedInputStream（面向字节）和PipedReader/PipedWriter（面向字符）。

 package Thread;

 import java.io.IOException;

 import java.io.PipedReader;

 import java.io.PipedWriter;

 /**

  * Created by Sky on 2016/9/22.

  * @author xiaoyongyong

  */

 public class Piped {

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

         PipedWriter out = new PipedWriter();

         PipedReader in = new PipedReader();

         out.connect(in);

         Thread printThread = new Thread(new Print(in), "PringThread");

         printThread.start();

         int receive;

         try {

             while ((receive = System.in.read()) != -1) {

                 out.write(receive);

             }

         } finally {

             out.close();

         }

     }

     private static class Print implements Runnable {

         private PipedReader in;

         public Print(PipedReader in) {

             this.in = in;

         }

         @Override

         public void run() {

             int receive;

             try {

                 while ((receive = in.read()) != -1) {

                     System.out.print((char) receive);

                 }

             } catch (IOException e) {

                 e.printStackTrace();

             }

         }

     }

 }

输入一串字符串，按enter后，将原样输出。管道输入输出流必须先连接才可复制，即connect()。

2.4 Thread.join()的使用

当线程A等待thread线程终止之后，才从thread.join()返回。

join方法顾名思义就是往线程中添加东西的；join方法可以用于临时加入线程，一个线程在运算过程中，如果满足于条件，我们可以临时加入一个线程，让这个线程运算完，另外一个线程再继续运行。

Thread,yeld()和Thread.sleep()的区别？

hread.yield()方法暂停当前正在执行的线程对象，并执行其他线程。也就是交出CPU一段时间(其他同样的优先级或者更高优先级的线程可以获取到运行的机会)；不会释放锁资源。

而Thread.sleep()方法使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行, 同时sleep函数不会释放锁资源；sleep可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会。

这两个的区别在于yield只能是同级，或者高级优先执行，而sleep可以低级，同级都可以有优先执行机会。

2.5 ThreadLocal的使用

线程变量，是一个以TreadLocal对象为键,任意对象为值得存储结构。

2.6 线程池技术及示例。

以下是线程池接口的定义和实现：

package Thread;

/**

 * Created by asus on 2016/9/27.

 */

public interface ThreadPool<Job extends Runnable> {

    void execute(Job job);

    void shutdown();

    void addWorkers(int num);

    void removeWoker(int num);

    int getJobSize();

}

package Thread;

import java.util.ArrayList;

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

import java.util.concurrent.atomic.AtomicLong;

/**

 * Created by asus on 2016/9/27.

 *

 * @author xiaoyongyong

 */

public class DefaultThreadPool<Job extends Runnable> implements ThreadPool<Job> {

    private static final int MAX_WORKER_NUMBERS = 10;

    private static final int DEFAULT_WORKER_NUMBERS = 5;

    private static final int MIN_WORKER_NUBERS = 1;

    private final LinkedList<Job> jobs = new LinkedList<Job>();

    private final List<Worker> workers = Collections.synchronizedList(new ArrayList<Worker>());

    private int workerNum = DEFAULT_WORKER_NUMBERS;

    private AtomicLong threadNum = new AtomicLong();

    public DefaultThreadPool() {

        initializeWorker(DEFAULT_WORKER_NUMBERS);

    }

    private void DefaultThreadPool(int num) {

        workerNum = num > MAX_WORKER_NUMBERS ? MAX_WORKER_NUMBERS : num < MIN_WORKER_NUBERS ? MAX_WORKER_NUMBERS : num;

        initializeWorker(workerNum);

    }

    @Override

    public void execute(Job job) {

        if (job != null) {

            synchronized (jobs) {

                jobs.add(job);

                jobs.notify();

            }

        }

    }

    @Override

    public void shutdown() {

        for (Worker worker : workers) {

            worker.shutdown();

        }

    }

    @Override

    public void addWorkers(int num) {

        synchronized (jobs) {

            if (num + this.workerNum > MAX_WORKER_NUMBERS) {

                initializeWorker(num);

                this.workerNum += num;

            }

        }

    }

    @Override

    public void removeWoker(int num) {

        synchronized (jobs) {

            if (num >= this.workerNum) {

                throw new IllegalArgumentException("beyond workerNum");

            }

            int count = 0;

            while (count < num) {

                Worker worker = workers.get(count);

                if (workers.remove(worker)) {

                    worker.shutdown();

                    count++;

                }

            }

            this.workerNum -= count;

        }

    }

    @Override

    public int getJobSize() {

        return jobs.size();

    }

    private void initializeWorker(int num) {

        for (int i = 0; i < num; i++) {

            Worker worker = new Worker();

            workers.add(worker);

            Thread threadWorker = new Thread(worker, "ThreadPool-Worker-" + threadNum.incrementAndGet());

            threadWorker.start();

        }

    }

    class Worker implements Runnable {

        private volatile boolean running = true;

        @Override

        public void run() {

            while (running){

                Job job = null;

                synchronized (jobs){

                    while (jobs.isEmpty()){

                        try {

                            jobs.wait();

                        } catch (InterruptedException e) {

                            Thread.currentThread().interrupt();

                            e.printStackTrace();

                            return;

                        }

                    }

                    job = jobs.removeFirst();

                }

                if(job != null){

                    job.run();

                }

            }

        }

        public void shutdown() {

            running = false;

        }

    }

}

2.7 基于县此次技术的简单Web服务器

这个服务器使用main线程不断接受客户端Socket的连接，将连接以及请求交给线程池处理，这样使得Web服务器能够同同时处理多个客户端请求。

巴特西