javase之实现多线程（重点）

java是单继承多实现

第一种方式：继承Thread

package com.ljl.thread;
/**
 * 模拟龟兔赛跑
 * 1、创建多线程，继承Thread，重写run（线程体）
 * 2、使用线程：创建子类对象，对象.start()--线程启动
 * @author Richard
 *
 */
public 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+"步");
		}
		
	}
}

package com.ljl.thread;

public class RabbitApp {
	
	public static void main(String[] args) {
		Rabbit rabbit=new Rabbit();//创建子类对象
		Tortoise tortoise=new Tortoise();
		rabbit.start();//调用start方法，不要调用run方法
		tortoise.start();
		
		for(int i=0;i<100;i++) {
			System.out.println("main"+i);
		}
		
	}

}

第二种方式：实现Runnable接口

package com.ljl.thread;
/**
 * 推荐 Runnable 创建线程
 *  1）避免单继承的局限性
 *  2）便于共享资源
 * 
 * 使用Runnable创建线程
 * 1、类 实现Runnable 接口+重写run
 * 2、启动多线程，使用静态代理
 * 		1）创建真实角色
 *      2）创建代理角色+真实角色的引用
 *      3）调用.start()启动线程
 * @author Richard
 *
 */
public class Programmer implements Runnable {
	//线程体
	@Override
	public void run() {
		for(int i=0;i<1000;i++) {
			System.out.println("一边听音乐");
		}
	}
}

package com.ljl.thread;

public class ProgrammerApp {
	
	public static void main(String[] args) {
//		1）创建真实角色
		Programmer programmer=new Programmer();
//	    2）创建代理角色+真实角色的引用(代理类已经帮我们写好了)
		Thread proxy=new Thread(programmer);
//		3）调用.start()启动线程
		proxy.start();
		
		for(int i=0;i<1000;i++) {
			System.out.println("一边打字");
		}
	}
}

 

 

package com.ljl.thread;
/**
 * 方便共享资源
 * @author Richard
 *
 */

public class Web12306 implements Runnable {
	private int num=100;
	
	@Override
	public void run() {
		while(true) {
			if(num<=0) {
				break;//跳出循环
			}
			System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
		}
	}
	
	public static void main(String[] args) {
		//真实角色
		Web12306 web12306=new Web12306();
		//代理角色
		Thread thread1=new Thread(web12306,"小明");
		Thread thread2=new Thread(web12306,"小红");
		Thread thread3=new Thread(web12306,"黄牛");
		
		thread1.start();
		thread2.start();
		thread3.start();
	}
	
	

}

 

第三种方式：实现callable接口（了解）--可声明异常和有返回值

package com.ljl.thread;

import java.sql.Time;
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;
/**
 * 服务器端编程
 * @author Richard
 * 比较复杂
 */
public class Call{
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程
		ExecutorService service=Executors.newFixedThreadPool(2);
		Race tortoise=new Race("乌龟",1000);
		Race rabbit=new Race("兔子",500);
		//获取值--增加泛型后，我们就不需要进行强转
		Future<Integer> result1=service.submit(tortoise);
		Future<Integer> result2=service.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+"步");
		//停止线程
		service.shutdownNow();
		
	}
}
class Race implements Callable<Integer> {
	
	private String name;//名称
	private long time;//延时时间
	private boolean flag=true;
	private int step=0;//步数
	
	public Race() {
		
	}
	public Race(String name) {
		super();
		this.name=name;
	}
	public Race(String name,long time) {
		super();
		this.name=name;
		this.time=time;
	}


	@Override
	public Integer call() throws Exception {
		while(flag) {
			Thread.sleep(time);//延时
			step++;
		}
		
		return step;
	}
	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;
	}
	

}