java笔记四

程序是计算机指令的集合，它以文件的形式存储在磁盘上。
进程：是一个程序在其自身的地址空间中的一次执行活动。
进程是资源申请、调度和独立运行的单位，因此，它使用系统中的运行资源；而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占用系统的运行资源。
线程：是进程中的一个单一的连续控制流程。一个进程可以拥有多个线程。
线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。

实现多线程程序的两种方式：
    （1）从Thread类继承；
    （2）实现Runnable接口。

Java运行时系统实现了一个用于调度线程执行的线程调度器，用于确定某一时刻由哪一个线程在CPU上运行。
在java技术中，线程通常是抢占式的而不需要时间片分配进程（分配给每个线程相等的CPU时间的进程）。抢占式调度模型就是许多线程处于可以运行状态（等待状态），但实际上只有一个线程在运行。该线程一直运行到它终止进入可运行状态（等待状态），或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下，低优先级的线程被高优先级的线程抢占，高优先级的线程获得运行的机会。
Java线程调度器支持不同优先级线程的抢先方式，但其本身不支持相同优先级线程的时间片轮换。
Java运行时系统所在的操作系统（例如：Windows2000）支持时间片的轮换，则线程调度器就支持相同优先级线程的时间片轮换。

线程的同步:
The code segments within a program that access the same object from separate, concurrent threads are called “critical sections”。
同步的两种方式：同步块和同步方法
每一个对象都有一个监视器，或者叫做锁。
同步方法利用的是this所代表的对象的锁。
每个class也有一个锁，是这个class所对应的Class对象的锁。

线程的死锁
哲学家进餐的问题
线程1锁住了对象A的监视器，等待对象B的监视器，线程2锁住了对象B的监视器，等待对象A的监视器，就造成了死锁。

每一个对象除了有一个锁之外，还有一个等待队列（wait set），当一个对象刚创建的时候，它的对待队列是空的。
我们应该在当前线程锁住对象的锁后，去调用该对象的wait方法。
当调用对象的notify方法时，将从该对象的等待队列中删除一个任意选择的线程，这个线程将再次成为可运行的线程。
当调用对象的notifyAll方法时，将从该对象的等待队列中删除所有等待的线程，这些线程将成为可运行的线程。
wait和notify主要用于producer-consumer这种关系中。

 

Test.java

java 代码

1. /*wait  
2.  public final void wait()  
3.  throws InterruptedException导致当前的线程等待，  
4.  直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。换句话说，  
5.  此方法的行为就好像它仅执行 wait(0) 调用一样。   
6.  当前的线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，  
7.  直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。  
8.  然后该线程将等到重新获得对监视器的所有权后才能继续执行。 */  
9.   
10. /*  
11.  * notify  
12.  public final void notify()唤醒在此对象监视器上等待的单个线程。  
13.  如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的  
14.  ，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。   
15.  直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式  
16.  与在该对象上主动同步的其他所有线程进行竞争；例如，  
17.  唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。   
18.  
19.  此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一，  
20.  线程可以成为此对象监视器的所有者：   
21.  
22.  通过执行此对象的同步 (Sychronized) 实例方法。   
23.  通过执行在此对象上进行同步的 synchronized 语句的正文。   
24.  对于 Class 类型的对象，可以通过执行该类的同步静态方法。   
25.  一次只能有一个线程拥有对象的监视器。   
26.  
27.  */  
28.   
29. //wait notify在同步 (Sychronized) 方法中调用，必须是同一对象的等待队列   
30.   
31.   
32. public class Test {   
33.  public static void main(String[] args) {   
34.   Queue q = new Queue();   
35.   Producer p = new Producer(q);   
36.   Consumer c = new Consumer(q);   
37.   p.start();   
38.   c.start();   
39.  }   
40.   
41. }   
42.   
43. class Queue {   
44.  int value;   
45.   
46.  boolean bFull = false;// 放置处是否有数据   
47.   
48.  public synchronized void put(int i) {   
49.   if (!bFull) {// 如果没有数据   
50.    value = i;// 放入参数数据   
51.    bFull = true;// 设置放置位为有数据   
52.    notify();// 通知在wait()线程   
53.   }   
54.   try {// if没有执行，即放置位置已经有数据   
55.    wait();// 等待（等位置为空的时候再put()数据进去)   
56.   } catch (Exception e) {   
57.    e.printStackTrace();   
58.   }   
59.   
60.  }   
61.   
62.  public synchronized int get() {   
63.   if (!bFull) {// 放置位置没有数据   
64.    try {   
65.     wait();// 等待   
66.    } catch (Exception e) {   
67.     e.printStackTrace();   
68.    }   
69.   }   
70.   bFull = false;// if没执行，即有数据，读取数据后将标志位置false   
71.   // 即读取了数据后可以再放数据到放置位了   
72.   notify();// 通知在wait()的线程   
73.   return value;   
74.   
75.  }   
76. }   
77.   
78. class Producer extends Thread {   
79.  Queue q;   
80.   
81.  Producer(Queue q) {   
82.   this.q = q;   
83.   
84.  }   
85.   
86.  public void run() {   
87.   for (int i = 0; i < 10; i++) {   
88.    q.put(i);//调用put()   
89.    System.out.println("Producer put" + i);   
90.   }   
91.  }   
92. }   
93.   
94. class Consumer extends Thread {   
95.  Queue q;   
96.   
97.  Consumer(Queue q) {   
98.   this.q = q;   
99.  }   
100.   
101.  public void run() {   
102.   while (true) {   
103.    System.out.println("Consumer get" + q.get());//调用get()   
104.   }   
105.  }   
106. }   
107.