Java-并发入门

本文由@呆代待殆原创，转载请注明出处：http://www.cnblogs.com/coffeeSS/

Java中实现多线程的方法

实现Runnable接口

实现Runnable接口里的run()方法，并将这个实例提交给一个Thread构造器，最后调用Thread.start()就可以启动一个线程。

 public class MyRunnable implements Runnable {
     String name;
     public MyRunnable(String name){
         this.name=name;
     }
     @Override
     public void run() {
         for(int i=0;i<5;++i){
             System.out.println(name+" 第 "+i+" 次运行");
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         System.out.println(name+" 运行完毕停机");
     }

 }

 public class Test {
     public static void main(String[] args){
         new Thread(new MyRunnable("0号机")).start();
         new Thread(new MyRunnable("1号机")).start();
     }
 }

继承Thread

直接继承Thread类，重写run()方法，调用Thread.start()即可

 public class MyThread extends Thread {
     public static void main(String[] args) {
         MyThread zero=new MyThread("0号机");
         MyThread one =new MyThread("1号机");
         zero.start();
         one.start();
     }
     String name;
     public MyThread(String name){
         this.name=name;
     }
     public void run(){
         for(int i=0;i<5;++i){
             System.out.println(name+" 第 "+i+" 次运行");
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         System.out.println(name+" 运行完毕停机");
     }
 }

线程的状态

线程有五个状态。

1、初始状态

　　Thread aThread = new Thread();

2、就绪状态

　　Thread aThread = new Thread();

　　Thread.start();

3、阻塞状态

　　suspend()

　　sleep()

　　wait()

　　输入输出流发生阻塞。

　　线程同步时试图锁住另一个线程锁住的对象。

　　...

4、运行状态

　　run()方法正在执行中。

5、死亡状态

　　stop()，或非预期的异常终止run()方法，线程突然死亡。

　　run()正常退出，线程自然死亡。

线程相关的常用方法简介(都有相应的在线API链接)

start()//启动线程，调用run()方法。

run()//一般我们需要重写这个方法给线程安排要执行的任务。

interrupt()//中断这个线程。

yield()//会让调用这个方法的线程睡眠。

wait()//让调用此方法的线程阻塞。

wait与sleep是不同的，调用了sleep 的线程仍然会占用cpu，且不会释放已经拿到的锁，但是不会有任何动作，调用了wait的线程不会占用cpu，会让出已经占用的锁。

sleep(long millis)//让当前线程睡眠millis毫秒

sleep(long millis, int nanos)//让当前线程睡眠millis毫秒nanos纳秒。

notify()//随机唤醒一个阻塞状态的线程。

notifyAll()//唤醒所有阻塞状态的线程。

setPriority(int newPriority)//用来设置线程的优先级JDK提供了10个优先级所以newPriority的取值是1-10，其中10是最高优先级。

注意大多数操作系统并不能和这10个优先级很好的映射，比如window只有7个优先级，而Sun的Solaris有2³¹个优先级，所以要想使优先级的设置操作是可移植的，最好用MAX_PRIORITY、NORM_PRIORITY、MIN_PRIORITY这三个预定义的常数来设置优先级。

getPriority()//返回线程优先级。

toString()//返回线程的名字、优先级和线程组。

setName(String name)//设置线程的名称。

getName()//获得线程的名字。

getId()//获得线程的identifier

setDaemon(boolean on)//标识是否是一个守护线程。

join()//当前线程会被挂起，等待调用这个方法的目标线程执行结束后再被唤醒（如：你在某个线程里写t.join()，则当前线程会挂起，t线程开始运行，t线程返回后，当前线程继续执行）。

join(long millis)//作用同上，但是如果millis毫秒后目标线程还没返回的话，目标线程会被强制中断，然后返回当前线程。

join(long millis, int nanos)//同上，只是时间更精确了。

isAlive()//测试这个线程是否还活着。

interrupted()//测试这个线程是否被中断。

关于线程的同步

synchronized关键字

synchronized有两种用法，用来修饰方法和用来修饰代码块。

1，修饰方法

synchronized关键字修饰方法的时候，这个方法只能被一个线程调用，当第二个线程想同时访问的时候，它将被阻塞直到第一个线程从方法返回。

如果一个对象中有很多个方法都被synchronized关键字修饰，由于它们是共享同一把锁的，也就是说，对其中某一个方法进行调用，将使得所有synchronized方法都不能被这个线程以为的其他线程调用。

这里要注意类的每一个实例都有一个自己的对象锁，一个实例里面的synchronized方法被访问会导致这个实例内其他synchronized方法不能访问，但是不会导致这个类的其他实例的synchronized方法不能用。

2，修饰代码块

修饰代码块的时候synchronized可以指定需要获取的锁，而且可以让同步的代码块更加精确。

关于锁，每个类有一个类锁，每个类的实例有一个对象锁，这两把锁互相不干扰。

当synchronized修饰static方法或者修饰的代码块指定的锁为XXX.class的话，将获得类锁，类锁管理所有的static方法的访问，获取类锁后，其他类的实例将无法访问所有的static方法，但是非static方法即使是用synchronized修饰的也可以访问。同理，即使获得对象锁后将使得其他非static的synchronized修饰的方法无法访问，但是static方法可以被访问，当然同一个对象可以同时获得者两把锁。

另外类锁只是一个抽象概念，并不存在真正的类锁，这里的类锁是代表着这个类的对象的对象锁。

使用Lock对象进行并发控制。

使用Lock对象的时候要注意有良好的格式，如下（图片来自网络）

aaarticlea/png;base64,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" alt="" width="628" height="261" />

lock.lock()方法将会让线程获得锁，如果这个时候有别的线程来取锁，则会陷入阻塞状态。

lock.unlock()方法会释放锁，写在finally里的原因是为了让任何情况下，锁都能得到释放，这里要强调的是return语句要写在try里面，以确保unlock()不会过早的发生。

使用Lock与使用synchronized的区别在于，如果使用synchronized，如果线程没有得到锁，它将一直等待下去，如果使用Lock，通过调用tryLock方法可以实现在失败的时候中断等待去干别的事情。详细情况如下。

tryLock()//如果获取了锁立即返回true，如果别的线程正持有锁，立即返回false。

tryLock(long timeout, TimeUnit unit)//如果获取了锁定立即返回true，如果别的线程正持有锁，会等待参数给定的时间，在等待的过程中，如果获取了锁定，就返回true，如果等待超时，返回false。

效率上，在资源竞争不是很激烈的情况下，synchronized的性能要更好，否则synchronized的性能会下降的很快，而Lock的性能一直很稳定。

死锁简介

当以下4个条件同时满足的时候就会发生死锁

1，互斥条件：存在不能共享的资源。

2，不可抢占条件：资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放。

3，请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。

4，环路等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

对于java线程的锁机制来说，互斥条件和不可抢占条件先天满足，所以我们能做到的就是不要让条件3和条件4也都满足就可以了。具体细节这里不做讨论。

管道流用于线程间通信

管道流的应用非常简单，相关的类有四个

用于字节流的PipedInputStream与PipedOutputStream

用于字符流的PipedReader与PipedWriter

它们都是配套使用的，用于两个线程间的通信，并且通信是单向的。

使用的基本流程如下，

1，创建对应的输出流和输入流。

2，用connect方法将它们连接起来，然后就可以使用了。

3，调用close方法释放资源。

输入流的read方法在没有更多数据的时候会自动阻塞。

另外用管道流进行读写的时候必须保证相对应的两个线程都不能退出，也不能阻塞。否则就会报java.io.IOException: Write/Read end dead 的错误。

下面给出一个实例，用PipedReader与PipedWriter实现两个线程间的通信，程序会不停的打印一段文字。

 public class TestPiped {
     PipedWriter pWriter;
     PipedReader pReader;

     public TestPiped() {
         pWriter = new PipedWriter();
         try {
             pReader = new PipedReader(pWriter);
         } catch (IOException e) {
             e.printStackTrace();
         }
         new Thread(new MyReader(pReader)).start();
         new Thread(new MyWriter(pWriter)).start();
     }

     public static void main(String[] args) {
         new TestPiped();
     }
 }

 class MyReader implements Runnable {
     PipedReader pReader;

     public MyReader(PipedReader pReader) {
         this.pReader = pReader;
     }

     @Override
     public void run() {
         while (true) {
             char c;
             int i;
             while (true) {
                 try {
                     i = pReader.read();
                     if (i == -1)
                         break;
                     c = (char) i;
                     System.out.print(c);
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             System.out.println();
             notifyAll();
         }
     }
 }

 class MyWriter implements Runnable {
     PipedWriter pWriter;

     public MyWriter(PipedWriter pWriter) {
         this.pWriter = pWriter;
     }

     @Override
     public void run() {
         while (true) {
             try {
                 pWriter.write(new String("番茄，番茄，这里是西红柿，收到请回答\n"));
                 Thread.sleep(2000);
             } catch (IOException e) {
                 e.printStackTrace();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }

 }

参考资料：

1，《java编程思想》中文 第四版

2，在线java API http://tool.oschina.net/apidocs/apidoc?api=jdk_7u4