09_1_線程的基本概念
阿新 • • 發佈：2018-04-28
spa pan rod throw ati 程序計數器 java extends all
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();
}
}
}
}
09_1_線程的基本概念