Java并发开发（Thinking In Java）

最新推荐文章于 2024-08-06 11:26:57 发布

紫龙队长

最新推荐文章于 2024-08-06 11:26:57 发布

阅读量180

点赞数

分类专栏： Java基础文章标签：并发编程

本文链接：https://blog.csdn.net/chao94w/article/details/96105917

版权

Java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前言

并发编程对于做后端的java工程师，是一项必备的技术能力，但是也是相对比较复杂的技术，这几天翻开尘封的Thinking In Java,读完了并发这一章，真的是读完，因为到后面很多的例子只能自己读懂，但是实际编写，还是需要再消化沉淀一下，才能写出来，下面就对这几天学习的内容做一个整理。

原理及意义

线程及进程的区别

进程是一个正在运行的应用程序，它包含一个或多个线程，是系统资源调度分配的基本单位。
线程是一组指令的集合或是一段程序的特殊段，是CPU调度的基本单位。
进程有自己独立的地址空间，一个进程挂掉后一般不影响其他进程。
线程没有自己独立的地址空间，他在进程中有不同的执行路径，线程有自己的堆栈和局部变量，不同线程可以共享进程内存信息。
本文所讲的并发编程，都是针对多线程的并发开发。

并发可以使程序更快的执行

要想一个程序运行的更快，在单线程编程中，我们只能不断优化自己的算法，降低自己的算法复杂度，但是这些都是有瓶颈的，应用程序一般只会越来越复杂，而并发编程，为Java开发打开了一道新的大门，很多复杂的流程，我们可以拆分成不同的任务，多线程进行，这样也可以充分发挥我们多核CPU的性能。
当然更快执行的代价也是有的，那就是并发编程会使我们的程序更加复杂，更加容易出错，当然，我们并不能因为难就不学，事实上，并发编程也是仿真学的基础入门，所以为了能够成为更好的程序员，让我们开始学习并发编程吧。

基本的线程机制

定义任务

最基本的定义任务的方式有两种实现Runnable接口，继承Thread父类。然后实现run方法。
Runnable实例

public class LiftOff implements Runnable {
  protected int countDown = 10; // Default
  private static int taskCount = 0;
  private final int id = taskCount++;
  public LiftOff() {}
  public LiftOff(int countDown) {
    this.countDown = countDown;
  }
  public String status() {
    return "#" + id + "(" +
      (countDown > 0 ? countDown : "Liftoff!") + "), ";
  }
  public void run() {
    while(countDown-- > 0) {
      System.out.print(status());
      Thread.yield();
    }
  }
} ///:~

Thread可以用Runnable进行构造，这样我们很容易添加更多的线程。

public class MoreBasicThreads {
  public static void main(String[] args) {
    for(int i = 0; i < 5; i++) {
      new Thread(new LiftOff()).start();
      System.out.println();
    }
    System.out.println("Waiting for LiftOff");
  }
} /* Output: (Sample)
Waiting for LiftOff
#0(9), #1(9), #2(9), #3(9), #4(9), #0(8), #1(8), #2(8), #3(8), #4(8), #0(7), #1(7), #2(7), #3(7), #4(7), #0(6), #1(6), #2(6), #3(6), #4(6), #0(5), #1(5), #2(5), #3(5), #4(5), #0(4), #1(4), #2(4), #3(4), #4(4), #0(3), #1(3), #2(3), #3(3), #4(3), #0(2), #1(2), #2(2), #3(2), #4(2), #0(1), #1(1), #2(1), #3(1), #4(1), #0(Liftoff!), #1(Liftoff!), #2(Liftoff!), #3(Liftoff!), #4(Liftoff!),
*///:~

使用Executor(线程池)

JavaSE5的java.util.concurrent包中提供了很多并发编程的工具，其中Executor就是为我们管理Thread对象，从而简化并发编程的。
ExecutorService是具有生命周期的Executor，用其更改上面的Thread实现。

public class CachedThreadPool {
  public static void main(String[] args) {
    ExecutorService exec = Executors.newCachedThreadPool();
    for(int i = 0; i < 5; i++)
      exec.execute(new LiftOff());
    exec.shutdown();
  }
} /* Output: (Sample)
#0(9), #0(8), #1(9), #2(9), #3(9), #4(9), #0(7), #1(8), #2(8), #3(8), #4(8), #0(6), #1(7), #2(7), #3(7), #4(7), #0(5), #1(6), #2(6), #3(6), #4(6), #0(4), #1(5), #2(5), #3(5), #4(5), #0(3), #1(4), #2(4), #3(4), #4(4), #0(2), #1(3), #2(3), #3(3), #4(3), #0(1), #1(2), #2(2), #3(2), #4(2), #0(Liftoff!), #1(1), #2(1), #3(1), #4(1), #1(Liftoff!), #2(Liftoff!), #3(Liftoff!), #4(Liftoff!),
*///:~

这里整理一下几种Executor

CachedThreadPool:创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
FixedThreadPool:创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
SingleThreadExecutor:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
newScheduledThreadPool:创建一个定长线程池，支持定时及周期性任务执行。

从任务中产生返回值

Runnable是执行工作的独立任务，但是它不返回任何值。
如果线程需要返回值，可以实现Callable接口。
下面是简单示例：

import java.util.concurrent.*;
import java.util.*;

class TaskWithResult implements Callable<String> {
  private int id;
  public TaskWithResult(int id) {
    this.id = id;
  }
  public String call() {
    return "result of TaskWithResult " + id;
  }
}

public class CallableDemo {
  public static void main(String[] args) {
    ExecutorService exec = Executors.newCachedThreadPool();
    ArrayList<Future<String>> results =
      new ArrayList<Future<String>>();
    for(int i = 0; i < 10; i++)
      results.add(exec.submit(new TaskWithResult(i)));
    for(Future<String> fs : results)
      try {
        // get() blocks until completion:
        System.out.println(fs.get());
      } catch(InterruptedException e) {
        System.out.println(e);
        return;
      } catch(ExecutionException e) {
        System.out.println(e);
      } finally {
        exec.shutdown();
      }
  }
} /* Output:
result of TaskWithResult 0
result of TaskWithResult 1
result of TaskWithResult 2
result of TaskWithResult 3
result of TaskWithResult 4
result of TaskWithResult 5
result of TaskWithResult 6
result of TaskWithResult 7
result of TaskWithResult 8
result of TaskWithResult 9
*///:~

exec.submit 调用后将返回Future对象，将包含返回的结果，Future.get()的时候，线程将会阻塞等待线程返回，此处可以调用isDone来判断线程是否返回。

休眠

Thread.sleep(休眠毫秒数)，JavaSE5引入更加显式的Sleep版本，TimeUnit.MILLISECONDS.sleep(100);里面MILLISECONDS可以更换成其他时间单位。

public class SleepingTask extends LiftOff {
  public void run() {
    try {
      while(countDown-- > 0) {
        System.out.print(status());
        // Old-style:
        // Thread.sleep(100);
        // Java SE5/6-style:
        TimeUnit.MILLISECONDS.sleep(100);
      }
    } catch(InterruptedException e) {
      System.err.println("Interrupted");
    }
  }
  public static void main(String[] args) {
    ExecutorService exec = Executors.newCachedThreadPool();
    for(int i = 0; i < 5; i++)
      exec.execute(new SleepingTask());
    exec.shutdown();
  }
} /* Output:
#0(9), #1(9), #2(9), #3(9), #4(9), #0(8), #1(8), #2(8), #3(8), #4(8), #0(7), #1(7), #2(7), #3(7), #4(7), #0(6), #1(6), #2(6), #3(6), #4(6), #0(5), #1(5), #2(5), #3(5), #4(5), #0(4), #1(4), #2(4), #3(4), #4(4), #0(3), #1(3), #2(3), #3(3), #4(3), #0(2), #1(2), #2(2), #3(2), #4(2), #0(1), #1(1), #2(1), #3(1), #4(1), #0(Liftoff!), #1(Liftoff!), #2(Liftoff!), #3(Liftoff!), #4(Liftoff!),
*///:~

优先级

线程的优先级是将线程的重要性传递给调度器，尽管CPU处理现有线程集的顺序是不确定性的，但是调度器会倾向于让优先级高的线程先执行。

//: concurrency/SimplePriorities.java
// Shows the use of thread priorities.
import java.util.concurrent.*;

public class SimplePriorities implements Runnable {
  private int countDown = 5;
  private volatile double d; // No optimization
  private int priority;
  public SimplePriorities(int priority) {
    this.priority = priority;
  }
  public String toString() {
    return Thread.currentThread() + ": " + countDown;
  }
  public void run() {
    Thread.currentThread().setPriority(priority);
    while(true) {
      // An expensive, interruptable operation:
      for(int i = 1; i < 100000; i++) {
        d += (Math.PI + Math.E) / (double)i;
        if(i % 1000 == 0)
          Thread.yield();
      }
      System.out.println(this);
      if(--countDown == 0) return;
    }
  }
  public static void main(String[] args) {
    ExecutorService exec = Executors.newCachedThreadPool();
    for(int i = 0; i < 5; i++)
      exec.execute(
        new SimplePriorities(Thread.MIN_PRIORITY));
    exec.execute(
        new SimplePriorities(Thread.MAX_PRIORITY));
    exec.shutdown();
  }
} /* Output: (70% match)
Thread[pool-1-thread-6,10,main]: 5
Thread[pool-1-thread-6,10,main]: 4
Thread[pool-1-thread-6,10,main]: 3
Thread[pool-1-thread-6,10,main]: 2
Thread[pool-1-thread-6,10,main]: 1
Thread[pool-1-thread-3,1,main]: 5
Thread[pool-1-thread-2,1,main]: 5
Thread[pool-1-thread-1,1,main]: 5
Thread[pool-1-thread-5,1,main]: 5
Thread[pool-1-thread-4,1,main]: 5
...
*///:~

让步

yield()方法是暗示CPU本线程的工作已经做的差不多了，可以让别的线程使用CPU了，这只是一种暗示，没有任何机制保证它将被采纳。yield是建议有相同优先级的其他线程可以执行。

后台线程

所谓后台线程，是指程序运行的时候，在后台提供一种通用服务的线程，这种线程不属于程序不可或缺的部分。
所以当所有非后台线程结束后，程序也会杀死进程中所有的后台线程。main（）就是一个非后台线程。

import java.util.concurrent.*;
import static net.mindview.util.Print.*;

public class SimpleDaemons implements Runnable {
  public void run() {
    try {
      while(true) {
        TimeUnit.MILLISECONDS.sleep(2100);
        print(Thread.currentThread() + " " + this);
      }
    } catch(InterruptedException e) {
      print("sleep() interrupted");
    }
  }
  public static void main(String[] args) throws Exception {
    for(int i = 0; i < 10; i++) {
      Thread daemon = new Thread(new SimpleDaemons());
      daemon.setDaemon(true); // Must call before start()
      daemon.start();
    }
    print("All daemons started");
    TimeUnit.MILLISECONDS.sleep(10000);
  }
} /* Output: (Sample)
All daemons started
Thread[Thread-0,5,main] SimpleDaemons@530daa
Thread[Thread-1,5,main] SimpleDaemons@a62fc3
Thread[Thread-2,5,main] SimpleDaemons@89ae9e
Thread[Thread-3,5,main] SimpleDaemons@1270b73
Thread[Thread-4,5,main] SimpleDaemons@60aeb0
Thread[Thread-5,5,main] SimpleDaemons@16caf43
Thread[Thread-6,5,main] SimpleDaemons@66848c
Thread[Thread-7,5,main] SimpleDaemons@8813f2
Thread[Thread-8,5,main] SimpleDaemons@1d58aae
Thread[Thread-9,5,main] SimpleDaemons@83cc67
...
*///:~

加入一个线程

一个线程可以在其他线程上使用join(),其效果时等待一段时间直到第二个线程结束才可以继续执行。如果某个线程在另一个线程t上调用t.join(),此线程将被挂起，直到目标线程t结束才恢复(即t.isAlive()返回为假)。
也可以在join()时带上一个超时参数，这样可以在目标线程时间到期后还没结束的话，join(）方法总能返回。
interrupt()方法可以中断join方法。
join的例子

import static net.mindview.util.Print.*;

class Sleeper extends Thread {
  private int duration;
  public Sleeper(String name, int sleepTime) {
    super(name);
    duration = sleepTime;
    start();
  }
  public void run() {
    try {
      sleep(duration);
    } catch(InterruptedException e) {
      print(getName() + " was interrupted. " +
        "isInterrupted(): " + isInterrupted());
      return;
    }
    print(getName() + " has awakened");
  }
}

class Joiner extends Thread {
  private Sleeper sleeper;
  public Joiner(String name, Sleeper sleeper) {
    super(name);
    this.sleeper = sleeper;
    start();
  }
  public void run() {
   try {
      sleeper.join();
    } catch(InterruptedException e) {
      print("Interrupted");
    }
    print(getName() + " join completed");
  }
}

public class Joining {
  public static void main(String[] args) {
    Sleeper
      sleepy = new Sleeper("Sleepy", 1500),
      grumpy = new Sleeper("Grumpy", 1500);
    Joiner
      dopey = new Joiner("Dopey", sleepy),
      doc = new Joiner("Doc", grumpy);
    grumpy.interrupt();
  }
} /* Output:
Grumpy was interrupted. isInterrupted(): false
Doc join completed
Sleepy has awakened
Dopey join completed
*///:~