进程是程序的一次性动态执行过程，它需要经历从代码加载，代码执行，到执行完毕的一个完整过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时运行多个进程（程序）。
多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是在进程的基础上进行的进一步划分。所谓多线程是指一个进程在执行过程中可以产生更小的程序单元，这些更小的单元称为线程，这些线程同时存在，同时运行，一个进程可能包含了多个同时执行的线程。
Java 中线程的实现
一，继承 Thread 类
二，Runnable 接口
public class Thread extends Object implements Runnable
(1), 线程的中断，合并，后台线程， 线程的休眠， 线程的优先级， 线程的礼让
(2), 线程的同步 与 死锁
(3), Object 类对线程的支持 -- 等待与唤醒
(4), 线程的生命周期
总结 ： Thread / Runnable run() 方法
在每一个线程创建和消亡之前，均会处于创建，就绪，运行，阻塞，终止 状态之一
TestThread1 入门
package com.qunar.basicJava.javase.p9thread;
/**
* Author: libin.chen@qunar.com Date: 14-5-20 14:17
*/
public class TestThread1 {
public static void main(String args[]) {
Runner1 r = new Runner1();
r.start();
// r.run();
// Thread t = new Thread(r);
// t.start();
for (int i = 0; i < 100; i++) {
System.out.println("Main Thread:------" + i);
}
}
}
// class Runner1 implements Runnable {
class Runner1 extends Thread {
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Runner1 :" + i);
}
}
}
// 马老师心得 ： 能使用接口，就尽量使用接口，别从 Thread 继承，因为缺少灵活性。TestInterrupt 线程的中断package com.qunar.basicJava.javase.p9thread;
/**
* Author: libin.chen@qunar.com Date: 14-5-20 14:19
*/
import java.util.*;
public class TestInterrupt {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
}
thread.interrupt();
}
}
class MyThread extends Thread {
boolean flag = true;
public void run() {
while (flag) {
System.out.println("===" + new Date() + "===");
try {
sleep(1000);
} catch (InterruptedException e) {
return;
}
}
}
}TestJoin 线程的合并package com.qunar.basicJava.javase.p9thread;
/**
* Author: libin.chen@qunar.com Date: 14-5-20 14:22
*/
public class TestJoin {
public static void main(String[] args) {
MyThread2 t1 = new MyThread2("abcde");
t1.start();
try {
t1.join(); // 合并线程，等待该线程结束，再恢复当前线程的执行
} catch (InterruptedException e) {
}
for (int i = 1; i <= 10; i++) {
System.out.println("i am main thread");
}
}
}
class MyThread2 extends Thread {
MyThread2(String s) {
super(s);
}
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println("i am " + this.getName()); // 线程名字
try {
sleep(1000);
} catch (InterruptedException e) {
return;
}
}
}
}
TestYield 线程的礼让package com.qunar.basicJava.javase.p9thread;
/**
* Author: libin.chen@qunar.com Date: 14-5-20 14:27
*/
public class TestYield {
public static void main(String[] args) {
MyThread3 t1 = new MyThread3("t1");
MyThread3 t2 = new MyThread3("t2");
t1.start();
t2.start();
}
}
class MyThread3 extends Thread {
MyThread3(String s) {
super(s);
}
public void run() {
for (int i = 1; i <= 30; i++) {
System.out.println(getName() + ": " + i);
if (i % 10 == 0) {
yield(); // 让出 CPU， 让当前线程进入队列等待
}
}
}
}
TestSync 线程的同步package com.qunar.basicJava.javase.p9thread;
/**
* Author: libin.chen@qunar.com Date: 14-5-20 14:40
*/
public class TestSync implements Runnable {
Timer timer = new Timer();
public static void main(String[] args) {
TestSync test = new TestSync();
Thread t1 = new Thread(test);
Thread t2 = new Thread(test);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
public void run() {
timer.add(Thread.currentThread().getName());
}
}
class Timer {
private static int num = 0;
public synchronized void add(String name) { // 锁定当前对象资源
// synchronized (this) {
num++;
try {
Thread.sleep(1);
} catch (InterruptedException e) {
}
System.out.println(name + ", 你是第" + num + "个使用timer的线程");
// }
}
}Thread-05- 线程同步-生产者与消费者的经典问题
package com.bjsxt.chap9Thread;
public class ProducerConsumer {
public static void main(String[] args) {
SyncStack ss = new SyncStack();
Producer p = new Producer(ss);
Consumer c = new Consumer(ss);
new Thread(p).start();
//new Thread(p).start();
//new Thread(p).start();
new Thread(c).start();
}
}
class WoTou {
int id;
WoTou(int id) {
this.id = id;
}
public String toString() {
return "WoTou : " + id;
}
}
class SyncStack {
int index = 0;
WoTou[] arrWT = new WoTou[6];
public synchronized void push(WoTou wt) {
while (index == arrWT.length) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();
arrWT[index] = wt;
index++;
}
public synchronized WoTou pop() {
while (index == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();
index--;
return arrWT[index];
}
}
class Producer implements Runnable {
SyncStack ss = null;
Producer(SyncStack ss) {
this.ss = ss;
}
public void run() {
for (int i = 0; i < 20; i++) {
WoTou wt = new WoTou(i);
ss.push(wt);
System.out.println("生产了：" + wt);
try {
Thread.sleep((int) (Math.random() * 200));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Consumer implements Runnable {
SyncStack ss = null;
Consumer(SyncStack ss) {
this.ss = ss;
}
public void run() {
for (int i = 0; i < 20; i++) {
WoTou wt = ss.pop();
System.out.println("消费了: " + wt);
try {
Thread.sleep((int) (Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}