【java学习笔记s】线程1

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

}