- 多线程
程序：指令集，静态的概念
进程：操作系统调动程序，是程序的一次动态执行过程，动态的概念
线程：在进程内的多条执行路径
Ps：单核的话进程都是虚拟模拟出来的，多核处理器才可以执行真正的多线程
单核通过CPU调度时间片实现虚拟模拟的多线程，比如执行main函数和GC在底层就是多线程，你执行你的，我执行我的
一个进程内部的线程共享相同的内存单元，可以访问相同的变量和对象，所以存在并发控制问题
线程和进程的区别：
-
根本区别：进程是资源分配的单位，而线程是调度和执行的单位
-
所处环境：多进程是指操作系统中可以有多个进程，多线程是同一个进程中有多个顺序流同时执行
-
切换开销：每个进程拥有自己独立的代码和数据空间（进程上下文），进程切换开销大，同一个进程内的线程因为是共享的进程的共享数据，所以线程切换的开销很小
-
分配内存：系统会为每个进程分配不同的内存区域，而却不会为线程分配，线程使用的是进程的资源
多线程的实现方法：
方法1：继承Thread类
Rabbit.java
package 多线程;
/**
* @author:yb
* @version 创建时间：2018-12-24 下午4:14:16 类说明
*/
/*
* 模拟龟兔赛跑
* 1.创建多线程：继承Thread+重写run()线程体
* 2.使用线程：创建子类对象+对象调用start()
*/
public class Rabbit extends Thread {
// 线程体
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("兔子跑了" + i + "步");
}
}
}
class Tortoise extends Thread {
// 线程体
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println("乌龟跑了" + i + "步");
}
}
}
RabbitApp.java
package 多线程;
/**
* @author:yb
* @version 创建时间：2018-12-24 下午4:20:53 类说明
*/
public class RabbitApp {
public static void main(String[] args) {
// 创建子类对象
Rabbit rab = new Rabbit();
Tortoise tor = new Tortoise();
// 调用start方法，不用调用run方法这个线程体
rab.start();
tor.start();
/*
* 为什么输出会是兔子跑了两步乌龟才开始跑呢？
* 因为是虚拟模拟实现的多线程，在底层cpu的按照时间片的轮转调度的，时间片先是给兔子这个对象
* 它先跑两部，然后时间片时间到了，cpu把时间片给乌龟，然后乌龟开始跑
* 实现的是虚拟的多线程（CPU轮流调度）
* 如果是多核计算机的话，那才是真正的多线程2
*/
}
}
分析直接继承Thread类这种方法的优缺点：
缺点：因为java的单继承，多实现，当我们一开始继承了其他类的时候，就不能继承Thread类了
优点：好像没有什么优点
为了避免这一情况，我们通过Runnable接口实现多线程
所以我们有了方法2：通过Runnable接口实现多线程
方法2：通过Runnable接口实现多线程
在这里使用了一种设计模式：静态代理，关于静态代理可以参考我的这篇博客：https://www.cnblogs.com/yinbiao/p/10169851.html
Programmer.java:
package 多线程;
/**
* @author:yb
* @version 创建时间：2018-12-25 下午7:05:34 类说明
*/
/*
* 使用Runnabke创建线程
* 1.类要实现Runnable接口+重写run方法体 -->真实角色
* 2.创建多线程 使用静态代理的设计模式
* 1）创建真实角色
* 2）创建代理角色+对真实角色的引用
* 3）调用start启动线程
*/
public class Programmer implements Runnable {
// 重写run方法体
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("第" + i + "次敲Hello world");
}
}
}
programmerApp.java:
package 多线程;
/**
* @author:yb
* @version 创建时间：2018-12-25 下午7:05:52 类说明
*/
public class ProgrammerApp {
public static void main(String[] args) {
// 1）创建真实角色
Programmer pro = new Programmer();
// 2）创建代理角色+对真实角色的引用
Thread proxy = new Thread(pro);
// 3）调用start启动线程
proxy.start();
// 另外一个线程，因为main函数也算是一个线程
for (int i = 0; i < 1000; i++) {
System.out.println("第" + i + "次打开wegame");
}
}
}
优点：
1.避免了单继承
2.方便共享资源，同一份资源，多个代理访问
共享资源的体现：（即同一个真实角色，多个代理）
代码背景：模拟人们在12306上抢火车票
Web12306.java：
package 多线程;
/**
* @author:yb
* @version 创建时间：2018-12-25 下午7:36:44 类说明
*/
/*
* 通过runnable接口实现多线程
* 可以方便共享资源，同一份资源，多个代理访问
* 代码背景：模拟人们在web12306上抢火车票
* 共享的是num，票资源
*/
public class Web12306 implements Runnable {
// 100张火车票
private int num = 50;
// 重写run方法体
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();
// 代理角色1
Thread t1 = new Thread(web12306, "顾客x");
// 代理角色2
Thread t2 = new Thread(web12306, "黄牛y");
// 代理角色3
Thread t3 = new Thread(web12306, "攻城狮z");
// 启动线程
t1.start();
t2.start();
t3.start();
}
}
记住：线程通过调用start（）方法是使得该进程进入就绪状态而不是运行状态！！！
方法三：线程池实现多线程，继承Callable接口
比较复杂，但是站服务器编程中应用广泛
参考一下这篇博客更好的理解此方法：https://www.cnblogs.com/yinbiao/p/10179563.html
代码背景：
还是多线程模拟龟兔赛跑
Call.java:
package 多线程;
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;
import org.omg.CORBA.INTERNAL;
/**
* @author:yb
* @version 创建时间：2018-12-25 下午8:07:11 类说明
*/
public class Call {
/*
* 使用Callable创造线程
*/
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(3000);//主线程挂起3000ms 乌龟和兔子线程开始竞争cpu 即乌龟和兔子开始跑，跑的时间都是3000ms
tortoise.setFlag(false);
rabbit.setFlag(false);
//获取值
int num1=result1.get();
System.out.println("乌龟跑了"+num1+"步");
int num2=result2.get();
System.out.println("兔子跑了"+num2+"步");
//停止服务
service.shutdownNow();
}
}
class Race implements Callable<Integer>{
private String name;//名称
private int time;//延时
private int step=0;//步数
public Race(String name,int time) {
super();
this.name=name;
this.time=time;
}
private boolean flag= true;
public int getTime() {
return time;
}
public void setTime(int 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;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer call() throws Exception{
while(flag) {
Thread.sleep(time);
step++;
}
return step;
}
}
分析：
通过继承Callable接口实现的多线程，可以对外声明异常和返回值，这是前面两个方法所不能实现的，但是此方法复杂繁琐
END！