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