Java 多线程（并发）

线程释义

使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。 
一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。 
Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。 
一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。 
一旦创建一个新的线程，就产生一个新的调用栈。

线程总体分两类：用户线程和守候线程。 
守护线程与用户线程的区别是： 
守护线程就是main同生共死，当main退出，它将终止，而普通线程是在任务执行结束才停止。守护线程则是用来服务用户线程的，如果没有其他用户线程在运行，那么就没有可服务对象，也就没有理由继续下去。 
Java虚拟机在它所有非守护线程已经离开后自动离开。 
但是daemon Thread实际应用在那里呢？举个例子，web服务器中的Servlet，容器启动时后台初始化一个服务线程，即调度线程，负责处理http请求，然后每个请求过来调度线程从线程池中取出一个工作者线程来处理该请求，从而实现并发控制的目的。

线程与进程

线程是进程中的最小执行单元。也就是说，进程包含线程，一个进程可以完成多个任务，每个任务就可以看作是一个线程。 
那什么又是进程呢。

1. 程序的执行过程是进程。

2. 持有资源和线程的是进程。

• 使用线程的目的是辅助写出CPU最大利用率的高效程序，使环境异步。

线程实现

• 实现Runnable接口的多线程例子

1. class DoSomething implements Runnable {
2. private String name;
3. public DoSomething(String name) {
4. this.name = name;
5. }
6. public void run() {
7. for (int i = 0; i < 5; i++) {
8. for (long k = 0; k < 10; k++)
9. System.out.println(name + ": " + i);
10. }
11. }
12. }
13. public class TestRunnable {
14. public static void main(String[] args) {
15. DoSomething ds1 = new DoSomething("阿三");
16. DoSomething ds2 = new DoSomething("李四");
17. Thread t1 = new Thread(ds1);
18. Thread t2 = new Thread(ds2);
19. t1.start();
20. t2.start();
21. }
22. }

• 扩展Thread类实现的多线程例子

1. /**
2. * 测试扩展Thread类实现的多线程程序
3. */
4. public class TestThread extends Thread{
5. public TestThread(String name) {
6. super(name);
7. }
8. public void run() {
9. for(int i = 0;i<5;i++){
10. for(long k= 0; k <10;k++)
11. System.out.println(this.getName()+" :"+i);
12. }
13. }
14. public static void main(String[] args) {
15. Thread t1 = new TestThread("阿三");
16. Thread t2 = new TestThread("李四");
17. t1.start();
18. t2.start();
19. }
20. }

对于上面的多线程程序代码来说，输出的结果是不确定的。其中的一条语句for(long k= 0; k <10;k++);是用来模拟一个非常耗时的操作的。

• 两者比较 
  继承方法目的是用多线程完成不同的任务，实现方法目的是用多线程完成相同的任务。 
  没有必要用run之外的方法的时候（除非是要加强或者修改），不要继承Thread类。

启动线程

在线程的Thread对象上调用start()方法，而不是run()或者别的方法。 
在调用start()方法之前：线程处于新状态中，新状态指有一个Thread对象，但还没有一个真正的线程。 
在调用start()方法之后：发生了一系列复杂的事情 
启动新的执行线程（具有新的调用栈）； 
该线程从新状态转移到可运行状态； 
当该线程获得机会执行时，其目标run()方法将运行。

注意：对Java来说，run()方法没有任何特别之处。像main()方法一样，它只是新线程知道调用的方法名称(和签名)。因此，在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。

同步和锁定

线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。 
需要完成两个操作：

1. 把竞争访问的资源类变量标识为private。
2. 同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。

• 锁 
  Java中每个对象都有一个内置锁 
  当程序运行到非静态的synchronized同步方法上时，自动获得与正在执行代码类的当前实例（this实例）有关的锁。获得一个对象的锁也称为获取锁、锁定对象、在对象上锁定或在对象上同步。 
  当程序运行到synchronized同步方法或代码块时才该对象锁才起作用。 
  一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。 
  一个线程可以获得多个锁 
  释放锁是指持锁线程退出了synchronized同步方法或代码块。
• volatile关键字 
  该关键字可以直接让被声明的变量直接在原始内存地址进行存取，而不是寄存器。虽然这样会失去优化性能的机会。
• 关于锁和同步，有一下几个要点： 
  1）、只能同步方法，而不能同步变量和类； 
  2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？ 
  3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。 
  4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。 
  5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。 
  6）、线程睡眠时，它所持的任何锁都不会释放。 
  7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。 
  8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。 
  9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。例如： 
  public int fix(int y) { 
  synchronized (this) { 
  x = x - y; 
  } 
  return x; 
  }

当然，同步方法也可以改写为非同步方法，但功能完全一样的，例如： 
public synchronized int getX() { 
return x++; 
} 
与 
public int getX() { 
synchronized (this) { 
return x; 
} 
} 
效果是完全一样的。

• 静态方法同步 
  要同步静态方法，需要一个用于整个类对象的锁，这个对象是就是这个类（XXX.class)。 
  例如： 
  public static synchronized int setName(String name){ 
  Xxx.name = name; 
  } 
  等价于 
  public static int setName(String name){ 
  synchronized(Xxx.class){ 
  Xxx.name = name; 
  } 
  }
• 死锁 
  一个线程访问一个对象内的一个同步块时，对象内其余的同步块将被锁定。因为访问那些块也需要锁，但是锁已经被拿走了。

线程间的交互

先看这三个方法 
void notify() 
唤醒在此对象监视器上等待的单个线程。 
void notifyAll() 
唤醒在此对象监视器上等待的所有线程。 
void wait() 
导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法。

当然，wait()还有另外两个重载方法： 
void wait(long timeout) 
导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者超过指定的时间量。 
void wait(long timeout, int nanos) 
导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

以上这些方法是帮助线程传递线程关心的时间状态。

关于等待/通知，要记住的关键点是： 
必须从同步环境内调用wait()、notify()、notifyAll()方法。线程不能调用对象上等待或通知的方法，除非它拥有那个对象的锁。 
wait()、notify()、notifyAll()都是Object的实例方法。与每个对象具有锁一样，每个对象可以有一个线程列表，他们等待来自该信号（通知）。线程通过执行对象上的wait()方法获得这个等待列表。从那时候起，它不再执行任何其他指令，直到调用对象的notify()方法为止。如果多个线程在同一个对象上等待，则将只选择一个线程（不保证以何种顺序）继续执行。如果没有线程等待，则不采取任何特殊操作。 
sleep();不放锁，这是它与wait的主要区别。

1. public class MyThreadPrinter implements Runnable {
3. private String name;
4. private Object prev;
5. private Object self;
7. private MyThreadPrinter2(String name, Object prev, Object self) {
8. this.name = name;
9. this.prev = prev;
10. this.self = self;
11. }
13. @Override
14. public void run() {
15. int count = 10;
16. while (count > 0) {
17. synchronized (prev) {
18. synchronized (self) {
19. System.out.print(name);
20. count--;
22. self.notify();
23. }
24. try {
25. prev.wait();
26. } catch (InterruptedException e) {
27. e.printStackTrace();
28. }
29. }
31. }
32. }
34. public static void main(String[] args) throws Exception {
35. Object a = new Object();
36. Object b = new Object();
37. Object c = new Object();
38. MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);
39. MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);
40. MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);
43. new Thread(pa).start();
44. new Thread(pb).start();
45. new Thread(pc).start(); }
46. }