Java 并发学习记录之线程间通信

Java 并发学习记录之线程间通信

volatile 和 synchronized 关键字

Java并发学习记录之volatile

Java并发学习记录之synchronized

等待/通知机制

Java并发学习记录之wait-notify机制

管道输入/输出流

管道输入/输出流和普通文件的输入/输出流或者网络输入、输出流不同之处在于管道输入/输出流主要用于线程之间的数据传输，
而且传输的媒介为内存。

管道输入/输出流主要包括下列两类的实现：

• 面向字节： PipedOutputStream、 PipedInputStream
• 面向字符: PipedWriter、 PipedReader

package com.littlefxc.examples.base.thread.pipe;

import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;

/**
 * 管道输入/输出主要用于线程间的数据传输，传输的媒介是内存。具体实现：
 * 
面向字节:
 * 

 * 
PipedWriter
 * 
PipedReader
 * 
 * 
面向字符:
 * 

 * 
PipedOutputStream
 * 
PipedInputStream
 * 
 *
 * @author fengxuechao
 * @date 2019/2/26
 **/
public class Piped {

    public static void main(String[] args) throws IOException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        // 将输出流和输入流进行必要的连接
        writer.connect(reader);
        Thread printThread = new Thread(new Print(reader), "PrintThread");
        printThread.start();
        int receive = 0;
        try {
            while ((receive = System.in.read()) != -1) {
                writer.write(receive);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            writer.close();
        }
    }

    static class Print implements Runnable {

        private PipedReader reader;

        public Print(PipedReader reader) {
            this.reader = reader;
        }

        @Override
        public void run() {
            int receive = 0;
            try {
                while ((receive = reader.read()) != -1) {
                    System.out.print((char) receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

运行该示例，输入一组字符串，可以看到 printThread 进行了原样输出。

Tips：
对于 Piped 类型的流，必须要进行绑定，也就是调用 connect()，否则会抛异常。

Thread.join() 的使用

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，
主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，
也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。另外，
一个线程需要等待另一个线程也需要用到join()方法。

Thread类除了提供 join() 方法之外，还提供了 join(long millis)、join(long millis, int nanos)
两个具有超时特性的方法。这两个超时方法表示，如果线程thread在指定的超时时间没有终止，
那么将会从该超时方法中返回。

重点看一下 join(long millis) 的示例：

package com.littlefxc.examples.base.thread;

/**
 * @author fengxuechao
 */
public class JoinLongTest {

    public static void main(String[] args) {
        try {
            MyThread threadTest = new MyThread();
            threadTest.start();

            threadTest.join(1000);// 主线成等待子线程1秒
//            Thread.sleep(1000);
            System.out.println("主线程结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static public class MyThread extends Thread {

        @Override
        public void run() {
            try {
                Thread.sleep(2000);
                System.out.println("子线程结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

运行结果：

ThreadLocal

之前我们讲保证线程资源安全问题时，使用同步加锁的方式保证线程安全。还有一种办法就是隔离资源的做法。

所谓的隔离，即每个线程使用自己的局部资源。将资源隔离不让其它线程访问，
从被隔离资源的角度来说，能够访问它的只有当前线程。既然只有当前线程可以访问的数据，自然是线程安全的。
一个典型的例子就是 Servlet。

ThreadLocal 的简单使用

首先来一个不使用 ThreadLocal 的类，然后在逐渐对其改造。

package com.littlefxc.examples.base.thread.threadlocal;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author fengxuechao
 * @date 2019/2/26
 **/
public class ThreadLocal1 {

    private static final SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            es.execute(new ParseDate(i));
        }
        es.shutdown();
    }

    private static class ParseDate implements Runnable {

        int i = 0;

        public ParseDate(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
ParseDateWithSync
                    Date date = SDF.parse("2019-02-26 16:23:" + i % 60);
                    System.out.println(i + ":" + date);
//                }
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：

一般这种问题主要是因为 SimpleDateFormat 在多线程环境下，是线程不安全的，所以如果你在多线程环境中共享了SimpleDateFormat的实例，
比如你在类似日期类中定义了一个全局的 SimpleDateFormat 对象，这样子肯定会出现上述的报错

一种解决办法就是加锁，在上面代码中可以将注释去掉后再次运行，也就不会出现这个问题了。

但是我现在要使用保存线程局部变量的ThreadLocal对象来保存每一个线程的SimpleDateFormat对象，针对上述代码做出改变：

package com.littlefxc.examples.base.thread.threadlocal;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author fengxuechao
 * @date 2019/2/26
 **/
public class ParseDateWithThreadLocal {

    static final String pattern = "yyyy-MM-dd HH:mm:ss";
    private static final ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>();

    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1000; i++) {
            es.execute(new ParseDate(i));
        }
        es.shutdown();
    }

    private static class ParseDate implements Runnable {

        int i = 0;

        public ParseDate(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            try {
                // 如果当前线程不持有 SimpleDateFormat 对象。那就新建并保存设置在当前线程中，如果已持有，则直接使用。
                if (threadLocal.get()==null) {
                    threadLocal.set(new SimpleDateFormat(pattern));
                }
                Date date = threadLocal.get().parse("2019-02-26 16:23:" + i % 60);
                System.out.println(i + ":" + date);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    }
}

注意：从上面代码中也可以看出，为每一个线程分配一个对象的工作并不是由 ThreadLocal 来完成的，
而是需要开发人员在应用层面保证的。ThreadLocal 只是起到了一个容器的作用。

ThreadLocal的原理

ThreadLocal的原理