09_1_线程的基本概念

09_1_线程的基本概念

1. 线程的基本概念

线程的一个程序内部的顺序控制流。

线程和进程的区别

每个进程都有独立的代码和数据空间(进程上下文)，进程间的切换会有较大的开销。

线程可以看成是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换的开销小。

多进程：在程序系统中同时运行多个任务(程序)。

多线程：在同一个应用程序中有多个顺序流同时执行

Java的线程是通过java.lang.Thread类来实现的。

VM启动时会有一个自主方法(public static void main() {})所定义的线程。

可以通过创建Thread的实例来创建新的线程。

每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。

通过调用Thread类的start()方法来启动一个线程。

1.1实现线程的两种方式之一

TestThread1

package Test;

 

public class TestThread1 {

 

public static void main(String[] args) {

Runner1 t  = new Runner1();

new  Thread(t).start();

for (int i = 0; i < 1000; i++) {

System.out.println("Main Thread" + i);

}

}

}

class Runner1 implements Runnable {

 

@Override

public void run() {

for (int i = 0; i < 1000; i++) {

System.out.println("Runner1 Thread" + i);

}

}

 

}

 

 

1.2实现线程的两种方式之一

TestThread2

package Test;

 

public class TestThread2 {

 

public static void main(String[] args) {

Runner2 t  = new Runner2();

t.start();

for (int i = 0; i < 1000; i++) {

System.out.println("Main Thread" + i);

}

}

}

class Runner2 extends Thread {

 

@Override

public void run() {

for (int i = 0; i < 1000; i++) {

System.out.println("Runner1 Thread" + i);

}

}

 

}

 

2. sleep方法

sleep方法

可以调用Thread的静态方法：

public static void sleep(long millis) throws InterruptedException

使得当前线程休眠(暂时停止执行millis毫秒)

由于是静态方法，sleep可以由类名直接调用：

Thread.sleep()

例子：

package Test;

 

import java.util.Date;

 

public class TestThread3 {

 

public static void main(String[] args) {

Runner3 t = new Runner3();

t.start();

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

}

t.interrupt();

}

}

class Runner3 extends Thread {

 

@Override

public void run() {

for (int i = 0; i < 1000; i++) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

return;

}

System.out.println("-------------" + new Date() + "---------------------");

}

}

 

}

 

 

3. 生产者消费者问题

 

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();
			}			
		}
	}
}