Java学习笔记（线程1）
1 、程序 进程 线程
程序：指令集 静态概念
进程：操作系统 调度程序 动态概念
线程：在进程内多条执行路径
实现多线程第一种方法：继承Thread，重写run方法，创建子类对象，调用子类对象的start方法
多线程实现的第二种方法：实现Runnable接口，重写run方法，使用静态代理。这种方法的好处是写法简单，缺点是没有返回值，不能抛异常。
1、创建真实角色
2、创建代理角色 Thread + 引用
3、调用代理角色的start方法
静态代理：
package com.bjsxt.thread.create;
/**
* 静态代理 设计模式
* 1、真实角色
* 2、代理角色:持有真实角色的引用
* 3、二者实现相同的接口
* @author yingjun
*
*/
public class StaticProxy {
public static void main(String[] args) {
//创建真实角色
Marry you = new You();
//创建代理角色 + 真实角色的引用
Marry company = new WeddingCompany(you);
//执行任务
company.marry();
}
}
//接口
interface Marry{
public abstract void marry();
}
//真实角色
class You implements Marry{
@Override
public void marry() {
System.out.println("you and 嫦娥结婚");
}
}
//代理角色
class WeddingCompany implements Marry{
private Marry you;
public WeddingCompany() {
}
public WeddingCompany(Marry you) {
this.you = you;
}
private void before() {
System.out.println("布置猪窝");
}
private void after() {
System.out.println("闹玉兔");
}
@Override
public void marry() {
before();
you.marry();
after();
}
}
实现多线程第三种方法：Callable接口
优点：可以返回值，可以声明异常
缺点：线程繁琐
1）、创建 Callable实现类+重写call方法
2）、借助 执行调度 ExecutorService,获取Future对象
ExecutorService ser = Executors.newFixedThreadPool(2);
Future result = ser.sunmit(实现对象)
3）、获取值 result.get()
4）、停止服务 ser.shutdownNow
package com.bjsxt.thread.create;
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 yingjun
*
*/
public class Call {
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 result1 = ser.submit(tortoise);
Future 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 {
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;
}
}
推荐第二种方法，第三种方法需要了解
