多线程

摘要：线程启动后系统就自动调用方法。守护线程的使用必须在之前设置，否则会跑出一个异常。你不能把正在运行的常规线程设置为守护线程。在线程中产生的新线程也是的。线程的同步控制使用方法可以释放对象锁，使用或可以让等待的一个或所有线程进入就绪状态。

一个进程中可以含有多个线程

在操作系统中可以查看线程数

如:在Windows中,在任务管理器,右键,选择列,选中“线程数”

分享CPU(并发的或以时间片的方式)
图示如下：

共享内存(如多个线程访问同一对象)

Java从语言级别支持多线程
如:
Object中wait(), notify(),java.lang中的类 Thread

线程启动后,系统就自动调用run()方法。参考相关书：

所以我们自己调用run是不会产生新的线程的。

通常,run()方法执行一个时间较长的操作

如一个循环

显示一系列图片

下载一个文件

class MyThread extends Thread {
    public void run() {
        for(int i=0;i<100;i++) {
            System.out.print (" " + i);
            public void run() { ...}
        }
//生成新线程
Thread thread = new Thread(mytask); thread.start();
    }
}

然而，并不推荐上述方式。参阅了《Introduction to Java Programming》:

This approach is, however, not recommended because it mixes the task and the mechanism of running the task. Separating the task from the thread is a preferred design.

因为Thread中还有其他的方法，这样可能会混淆了Thread中固有的机制。
Thread类的方法很多，如下：

所以，更好的方式是重新定义一个类来实现抽象类Runnable类，然后采用基于接口的对象注入的方式新建一个Thread的对象。如第二个方法。

class MyTask implements Runnable {
    public void run() { ...}
    }
//生成新线程
Thread thread = new Thread(mytask); thread.start();
}

图示如下：

使用示例：

public class TestThread4Anonymous {
    public static void main(String args[]) {
        //匿名类
        new Thread(){
            public void run() {
                for(int i=0; i<10; i++)    
                    System.out.println(i);
            }
        }.start();
        //Lambda表达式
        new Thread( ( ) -> { 
            for(int i=0; i<10; i++) 
                System.out.println(" "+ i); 
        } ).start();
    }
}

线程的启动：thread.start()

线程的结束：常用的方法是设定一个标记变量,结束相应的循环及方法。

暂时阻止线程的执行，比如在线程中用暂停方法：thread.sleep( 1000 );

调用设定线程的优先级setPriority( int priority)方法，默认有以下三种
MIN_PRIORITY,MAX_PRIORITY,NORM_PRIORITY

线程有两种:

一类是普通线程(非Daemon线程)
在Java程序中,若还有非Demon线程,则整个程序就不会结束

一类是Daemon线程(守护线程,后台线程)
使用setDaemon(true);如果普通线程结束了,则后台线程自动终止。

注:垃圾回收线程是后台线程

public class daemon {
    public static void main(String args[]) {
        //创建子线程
        Runnable t = new MyThread2();
        Thread thread = new Thread(t);
        thread.setDaemon(true);
        thread.start();

        System.out.println( "主线程开始运行." );
        try{
            Thread.sleep(500);
        }
        catch(InterruptedException ex){}
        System.out.println("主线程结束,子线程由于设置为守护线程,所以也应该提前结束.");
    }
}

class MyThread2 implements Runnable {
    public void run() {
        for(int i=0; i<10; i++ ){
            System.out.println(  "子线程应该循环10次,当前的第"+i+"次");
            try{ Thread.sleep(100); }
            catch(InterruptedException ex){}
        }
    }
}

输出结果：

主线程开始运行.
子线程应该循环10次,当前的第0次
子线程应该循环10次,当前的第1次
子线程应该循环10次,当前的第2次
子线程应该循环10次,当前的第3次
子线程应该循环10次,当前的第4次
主线程结束,子线程由于设置为守护线程,所以也应该提前结束.

可以从上面看出，守护线程即使在运行中，也应该随着主线程的结束而提前结束。

thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。

在Daemon线程中产生的新线程也是Daemon的。

守护线程应该永远不去访问固有资源，如文件、数据库，因为它会在任何时候甚至在一个操作的中间发生中断。

为什么线程需要同步：
同时运行的线程需要共享数据、就必须考虑其它线程的状态与行为,这时就需要实现同步。

Java引入了对象互斥锁的概念,来保证共享数据操作的完整性。
每个对象都对应于一个monitor(监视器),它上面 一个称为“互斥锁(lock, mutex)”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
关键字synchronized用来与对象的互斥锁联系。

synchronized的用法(2种)

对代码片断:

synchronized(对象){ 。。。。}

对某个方法:

synchronized放在方法声明中，如
public synchronized void push(char c ){ 。。。。}

以上相当于对synchronized(this), 表示整个方法为同步方法。

使用wait()方法可以释放对象锁，使用notify()或notifyAll()可以让等待的一个或所有线程进入就绪状态。
Java里面可以将wait()和notify()放在synchronized里面,是因为Java是这样处理的:

在synchronized代码被执行期间,线程调用对象的wait()方法,会释放对象锁标志,然后进入等待状态,然后由其它线程调用notify()或者notifyAll()方法通知正在等待的线程。

JDK1.5中增加了更多的类,以便更灵活地使用锁机制
Lock接口、ReentrantLock类，如下：

ReadWriteLock接口、ReentrantReadWriteLock类
如.writeLock(),.lock(), .readLock(),.unlock()，这些方法。

java.util.concurrent包中增加了一些方便的类

常用于很少写入而读取频繁的对象

CopyOnWriteArrayList、 CopyOnWriteArraySet

ConcurrentHashMap

putIfAbsent(), remove(), replace()

ArrayBlockingQueue

ExecutorService 接口、ThreadPoolExecutor 类

Executors 工具类
他们同样位于Concurrent接口的实现下面，如下：

ExecutorService pool = Executors.newCachedThreadPool();

使用其execute( Runnable r)方法

import java.util.concurrent.*;
/** 创建线程池示例
   */
public class ExecutorDemo {
  public static void main(String[] args) {
    // 创建线程池对象
    ExecutorService  executor = Executors.newCachedThreadPool();
    
    // 提交任务到线程池
    executor.execute(new PrintChar("a", 4));
    executor.execute(new PrintChar("b", 2));
    executor.execute(new PrintNum(2));
    //关闭线程池
    executor.shutdown();
   }
}
class PrintChar implements Runnable {
  private char charToPrint; // The character to print
  private int times; // The times to repeat

  /** 给定打印次数，打印特定字符
   */
  public PrintChar(char c, int t) {
    charToPrint = c;
    times = t;
  }

输出结果

aaaabb 1 2

这里是指Java8新增的函数式思想，并不是具体的文件输入输出流。使得某些编程语句更加流畅的表达。
比如，对数组进行流化：

Arrays.stream(a)
    .filter( i -> i>20 )
    .map(i->i*i)
    .sorted()
    .distinct()
    .limit(10)
    .max();

流操作分成两类:

中间的 -中间的操作保持流打开状态,并允许后续的操作。

如: filter sorted limit map

末端的 - 末端的操作必须是对流的最终操作。

如: max min count forEach findAny

从某个源头获得一个流。

执行一个或更多的中间的操作。

执行一个末端的操作。

对于数组

Arrays.stream(ary)

对于collection (包括List)

用 list.stream()

对于Map，没有流,但提供了类似的方法

如map.putIfAbsent

map.computeIfPresent

map.merge

import java.util.*;
class UseStream
{
    public static void main(String[] args)
    {
        List a = Arrays.asList(1,2,5,7,3);
        System.out.println(
                a.stream()
                        .mapToInt(i->(int)i)
                        .filter( i -> i>2 )
                        .map( i -> i*i )
                        .sorted()
                        .distinct()
                        .limit(10)
                        .max()
        );
    }
}

运行结果：

OptionalInt[49]

只需将上面代码的.stream()换成 .parallelStream()。

其他都不变,就可以实现并行计算

可以说，stream就是为并行运算而生的，它封装的并行计算的大量内部细节。