1,程序、进程、线程
程序:Program,是一个静态的概念
进程:Process,是一个动态的概念
1)进程是程序的一次动态执行过程,占用特定的地址空间
2)每个进程都是独立的,由3部分组成cpu,data,code
3)缺点:内存的浪费,cpu的负担
线程:Thread,是进程中一个“单一的连续控制流程”
1)线程又被称为轻量级进程
2)一个进程可拥有多个并行的线程
3)一个进程中的线程共享相同的内存单元/内存地址空间-->可以访问相同的变量和对象,而且它们从同一堆中分配对象-->通信、数据交换、同步操作
4)由于线程间的通信是在同一个地址空间上进行的,所以不需要额外的通信机制,这就使得通信更简便而且信息传递的速度也更快。
线程和进程的区别
2,线程创建的三种方式
2.1 创建Thread实例的方法
1) 通过创建Thread的实例来创建新的线程。
2)每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体。
3)通过调用Thread类的start()方法来起动一个线程
package cn.zxb.test;
/**
* 1,创建多线程 继承Thread +重写run()(线程体)
* 2,使用线程:创建子类对象+对象.start() 线程启动
*
*
*/
public class TestThread01 {
public static void main(String[] args) {
//创建子类对象
Rabbit rab = new Rabbit();
Tortoise tor = new Tortoise();
//调用start方法
rab.start();//不要调用run()方法
tor.start();
for(int i=0;i<100;i++){
System.out.println("mian>>"+i);
}
}
}
class Rabbit extends Thread{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println("兔子跑了"+i+"步");
}
}
}
class Tortoise extends Thread{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println("乌龟跑了"+i+"步");
}
}
}
2.2 实现Runnable+run()的方法
静态代理实现线程:因为Thread类里已经实现了Runnable接口,那个Thread类就是代理角色,我们只需创建真实角色,交由Thre管理即可。package cn.zxb.test;
/**
* 使用Runnable创建线程
* 1,类 实现Runnable接口 +重写run() 真实角色类
* 2,启动多线程 使用静态代理
* 1)创建真实角色
* 2)创建代理角色+真实角色引用
* 3)调用代理角色.start()启动线程
*
*/
public class TestThread02 {
public static void main(String[] args) {
//1)创建真实角色
Programmer pro = new Programmer();
//2)创建代理角色+真实角色引用
Thread proxy = new Thread(pro);
//3)调用。start()启动线程
proxy.start();
for(int i= 0;i<1000;i++){
System.out.println("一边聊QQ...");
}
}
}
class Programmer implements Runnable{
@Override
public void run() {
for(int i= 0;i<1000;i++){
System.out.println("一边敲hello...");
}
}
}
推荐使用此方法:
1)避免单继承的局限性
2)便于共享资源
2.3通过Callable接口实现多线程
优点:可以获取返回值
思路:
1)创建Callable实现类+重写call
2)借助执行调度服务ExecutorService,获取Future对象
ExecutorService ser = Executors.newFixedThreadPool(2);
Future result = ser.submit(实现类对象)
3)获取值result.get()
4)停止服务ser.shutdownNow()
package cn.zxb.test;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* 使用Callable创建线程
* @author zhaixiangbo
*
*/
public class TestThread03 {
public static void main(String[] args) throws InterruptedException, ExecutionException{
//创建线程
ExecutorService ser = Executors.newFixedThreadPool(2);//括号里是线程数
Race tortoise = new Race("乌龟",1000);
Race rabbit = new Race("兔子",500);
//获取值
Future<Integer> result1 = ser.submit(tortoise);
Future<Integer> result2 = ser.submit(rabbit);
Thread.sleep(2000);//跑多长时间,2秒后停下来
tortoise.setFlag(false); //停止线程体循环
rabbit.setFlag(false);
int num1 = result1.get();
int num2 = result2.get();
System.out.println("乌龟跑了"+num1+"步");
System.out.println("兔子跑了"+num2+"步");
//停止服务
ser.shutdownNow();
}
}
class Race implements Callable<Integer>{
private String name;
private long time;
private boolean flag = true;
private int step=0; //步数
@Override
public Integer call() throws Exception {
while(flag){
Thread.sleep(time);
step++;
}
return step;
}
public Race(String name, long time) {
super();
this.name = name;
this.time = time;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getTime() {
return time;
}
public void setTime(long time) {
this.time = time;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public int getStep() {
return step;
}
public void setStep(int step) {
this.step = step;
}
}