Java中的多线程使用

Thread：

 Thread thread = new Thread() {
     @Override
     public void run() {
         System.out.println("Thread started!");
     }
 };
 thread.start();

Thread类的几个常用的方法：

• sleep()：静态方法，使当前线程睡眠一段时间；
• currentThread()：静态方法，返回对当前正在执行的线程对象的引用；
• start()：开始执行线程的方法，java虚拟机会调用线程内的run()方法；
• join()：使当前线程等待另一个线程执行完毕之后再继续执行，内部调用的是Object类的wait方法实现的；
• yield()：yield意为放弃，yield()方法指当前线程愿意让出对当前处理器的占用。需要注意，即时当前线程调用了yield()方法让出处理机，调度时也有可能继续让该线程竞争获得处理机并运行；

Runnable：

Runnable是一个函数式接口：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Runnable不利于线程重用管理

 Runnable runnable = new Runnable() {
     @Override
     public void run() {
         System.out.println("Thread with Runnable started!");
     }
 };
 Thread thread = new Thread(runnable);
 thread.start();

ThreadFactory：

    ThreadFactory factory = new ThreadFactory() {
        int count = 0;
        @Override
        public Thread newThread(Runnable r) {
            count ++;
            return new Thread(r, "Thread-" + count);
        }
    };
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "started!");
        }
    };
    Thread thread = factory.newThread(runnable);
    thread.start();
    Thread thread1 = factory.newThread(runnable);
    thread1.start();

Executor线程池：

Executor线程池（最为推荐）：

 Runnable runnable = new Runnable() {
     @Override
     public void run() {
         System.out.println("Thread with Runnable started!");
     }
 };
 Executor executor = Executors.newCachedThreadPool();
 executor.execute(runnable);
 executor.execute(runnable);
 executor.execute(runnable);

Callable 和 Future：

Callable与Runnable类似，同样是只有一个抽象方法的函数式接口。不同的是，Callable提供的方法是有返回值的，而且支持泛型。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

Callable和Future一般成对出现，future.get()获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。

 Callable<String> callable = new Callable<String>() {
        @Override
        public String call() {
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Done!";
        }
    };
    ExecutorService executor = Executors.newCachedThreadPool();
    Future<String> future = executor.submit(callable);
    try {
        String result = future.get();
        System.out.println("result: " + result);
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }

线程安全和线程同步

线程安全：指函数在多线程环境中被调用时，能够正确地处理多个线程之间的全局变量，使得功能正确完成。

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作。

线程同步不等于线程安全，现在很多人误解了这一点而喜欢将他们混为一谈。现实是，当我询问面试者何为线程同步时，很多人回答的都是线程安全。

线程同步是实现线程安全的一种手段，你当然也可以用其他的方式达到线程安全。

Threadsafe vs Synchronized

线程安全的本质问题是资源问题：

当一个共享资源被一个线程读操作时，该资源不能被其他线程任意写；

当一个共享资源被一个线程写操作时，该资源不能被其他线程任意读写；

下面介绍java中实现线程安全的几种方式：

synchronized

synchronized以同步方式保证了方法内部或代码块内部资源(数据)的互斥访问，保证了线程之间对监视资源的数据同步.

 private synchronized void count(int newValue) {
        x = newValue;
        System.out.println("x= " + x);
    }

另一种写法：

 private void count(int newValue) {
    synchronized (this) {
        x = newValue;
        System.out.println("x= " + x);
    }
}

volatile

volatile关键字修饰的变量具有原子性和同步性，相当于实现了对单⼀字段的线程间互斥访问。

volatile关键字能够保证内存的可见性，如果用volatile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其它线程是立马可见更改后的值的。

volatile可以看做是简化版的 synchronized.

volatile 只对基本类型 (byte、char、short、int、long、float、double、boolean)的赋值操作和对象的引⽤赋值操作有效。

java.util.concurrent.atomic:

AtomicInteger、AtomicBoolean 等类，作⽤和 volatile 基本⼀致，可以看做是 volatile修饰的Integer、Boolean等类。

Lock / ReentrantReadWriteLock

Lock同样是加锁机制，但使⽤⽅式更灵活，同时也更麻烦：

Lock lock = new ReentrantLock();
...
lock.lock();
try {
    x++;
} finally {
    lock.unlock();
}

Synchronized存在的一个性能问题就是读与读之间互斥，所以我们⼀般并不会只是使⽤ Lock ，⽽是会使⽤更复杂的锁，例如 ReadWriteLock ，从而进行一些更加细致化的操作，如下代码：

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
Lock readLock = lock.readLock();
Lock writeLock = lock.writeLock();
private int x = 0;
private void writeOperate () {
    writeLock.lock();
    try {
        x++;
    } finally {
        writeLock.unlock();
    }
}
private void readOperate ( int time){
    readLock.lock();
    try {
        System.out.println();
    } finally {
        readLock.unlock();
    }
}

读取锁是共享的，因而上述代码中，有线程写操作时，其他线程不可写，不可读；该线程读操作时，其他线程不可写，但可读。

线程间通信/交互

线程有自己的私有空间，但当我多个线程之间相互协作的时候，就需要进行线程间通信方，本节将介绍Java线程之间的几种通信原理。

锁与同步

这种方式主要是对全局变量加锁，即用synchronized关键字对对象或者代码块加锁lock，来达成线程间通信。

这种方式可详见上一节线程同步中的例子。

等待/通知机制

基于“锁”的方式需要线程不断去尝试获得锁，这会耗费服务器资源。

Java多线程的等待/通知机制是基于Object类的wait()方法和notify(), notifyAll()方法来实现的，

wait()方法和notify()方法必须写在synchronized代码块里面：

wait()和notify()方法必须通过获取的锁对象进行调用，因为wait就是线程在获取对象锁后，主动释放对象锁，同时休眠本线程，直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作，因而必须放在加锁的synchronized代码块环境内。

notify()方法会随机叫醒一个正在等待的线程，而notifyAll()会叫醒所有正在等待的线程，被唤醒的线程重新在就绪队列中按照一定算法最终再次被处理机获得并进行处理，而不是立马重新获得处理机。

public class mythread {

    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadA: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadB: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }


    public static void main(String[] args) {
        new Thread(new ThreadA()).start();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new ThreadB()).start();


    }
}

join方法

join()方法让当前线程陷入“等待”状态，等join的这个线程执行完成后，再继续执行当前线程。

当主线程创建并启动了耗时子线程，而主线程早于子线程结束之前结束时，就可以用join方法等子线程执行完毕后，从而让主线程获得子线程中的处理完的某个数据。

join()方法及其重载方法底层都是利用了wait(long)这个方法。

public class mythread {

    static class ThreadA implements Runnable {

        @Override
        public void run() {
            try {
                System.out.println("子线程睡一秒");
                Thread.sleep(1000);
                System.out.println("子线程睡完了一秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadA());
        thread.start();
        thread.join();
        System.out.println("如果不加join方法，这行就会先打印出来");
    }
}

sleep方法

sleep方法是Thread类的一个静态方法。它的作用是让当前线程睡眠一段时间：

• Thread.sleep(long)

这里需要强调一下：**sleep方法是不会释放当前的锁的，而wait方法会。**这也是最常见的一个多线程面试题。

sleep方法和wait方法的区别：

• wait可以指定时间，也可以不指定；而sleep必须指定时间。
• wait释放cpu资源，同时释放锁；sleep释放cpu资源，但是不释放锁，所以易死锁。
• wait必须放在同步块或同步方法中，而sleep可以再任意位置

ThreadLocal类

ThreadLocal是一个本地线程副本变量工具类，可以理解成为线程本地变量或线程本地存储。严格来说，ThreadLocal类并不属于多线程间的通信，而是让每个线程有自己“独立”的变量，线程之间互不影响。

ThreadLocal类最常用的就是set方法和get方法。示例代码：

public class mythread {
    static class ThreadA implements Runnable {
        private ThreadLocal<String> threadLocal;

        public ThreadA(ThreadLocal<String> threadLocal) {
            this.threadLocal = threadLocal;
        }

        @Override
        public void run() {
            threadLocal.set("A");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadA输出：" + threadLocal.get());
        }

        public static void main(String[] args) {
            ThreadLocal<String> threadLocal = new ThreadLocal<>();
            new Thread(new ThreadA(threadLocal)).start();
        }
    }
}

可以看到，ThreadA可以存取自己当前线程的一个值。如果开发者希望将类的某个静态变量（user ID或者transaction ID）与线程状态关联，则可以考虑使用ThreadLocal，而不是在每个线程中声明一个私有变量来操作，加“重”线程。

InheritableThreadLocal是ThreadLocal的继承子类，不仅当前线程可以存取副本值，而且它的子线程也可以存取这个副本值。

信号量机制

JDK提供了一个类似于“信号量”功能的类Semaphore。在多个线程（超过2个）需要相互合作的场景下，我们用简单的“锁”和“等待通知机制”就不那么方便了。这个时候就可以用到信号量。JDK中提供的很多多线程通信工具类都是基于信号量模型的。

管道

管道是基于“管道流”的通信方式。JDK提供了PipedWriter、 PipedReader、 PipedOutputStream、 PipedInputStream。其中，前面两个是基于字符的，后面两个是基于字节流的。

应用场景：管道多半与I/O流相关。当我们一个线程需要先另一个线程发送一个信息（比如字符串）或者文件等等时，就需要使用管道通信了。

public class Pipe {
    static class ReaderThread implements Runnable {
        private PipedReader reader;

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

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

    static class WriterThread implements Runnable {

        private PipedWriter writer;

        public WriterThread(PipedWriter writer) {
            this.writer = writer;
        }

        @Override
        public void run() {
            System.out.println("this is writer");
            int receive = 0;
            try {
                writer.write("test");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        writer.connect(reader); // 这里注意一定要连接，才能通信

        new Thread(new ReaderThread(reader)).start();
        Thread.sleep(1000);
        new Thread(new WriterThread(writer)).start();
    }
}

// 输出：
this is reader
this is writer
test

参考：

concurrent.redspider.group/

www.matools.com/api/java8