目录
线程的概念
程序、进程、线程
- 程序：Program，指令集，是一个静态的概念
- 进程：Process，操作系统调度程序，是一个动态的概念
- 进程是程序的一次动态执行过程，占用特定的地址空间
- 每个进程都是独立的，由3部分组成 cpu, data, code
- 缺点：内存的浪费，cpu的负担
- 线程：Thread，是进程中一个“单一的连续控制流程”（a single sequential flow of control）/执行路径，在进程内多条执行路径
- 线程又被称为轻量级进程(lightweight process)
- 一个进程可拥有多个并行的(concurrent)线程
- 一个进程中的线程共享相同的内存单元/内存地址空间→可以访问相同的变量和对象，而且它们从同一堆中分配对象→通信、数据交换、同步操作
- 由于线程间的通信是在同一地址空间上进行的，所以不需要额外的通信机制，这就使得通信更简便而且信息传递的速度也更快
线程和进程的区别
| 区别 | 进程 | 线程 |
|---|---|---|
| 根本区别 | 作为资源分配的单位 | 调度和执行的单位 |
| 开销 | 每个线程都有独立的代码和数据空间（程序上下文），进程间的切换会有较大的开销 | 线程可以看成时轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小 |
| 所处环境 | 在操作系统中能同时运行多个任务（程序） | 在同一应用程序中有多个顺序流同时执行 |
| 分配内存 | 系统在运行的时候会为每个进程分配不同的内存区域 | 除了CPU之外，不会为线程分配内存（线程所使用的资源是它所属的进程的资源），线程组只能共享资源 |
| 包含关系 | 没有线程的进程是可以被看作单线程的，如果一个进程内拥有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的 | 线程是进程的一部分，所以线程有的时候被称为是轻权进程或者轻量级进程 |
实现多线程
方法一
- 在Java中负责线程的这个功能的是 Java.lang.Thread这个类
- 可以通过创建 Thread的实例来创建新的线程
- 每个线程都是通过某个特定 Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体
- 通过调用 Thead类的 start()方法来启动一个线程
eg:龟兔赛跑
/**
* 模拟龟兔赛跑
* 1.创建多线程 继承 Thread +重写Run(线程体)
* 2.使用线程：创建子类对象 +对象.start() 线程启动
* @author qiao39gs
*
*/
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+"步");
}
}
}public class RabbitApp {
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("main————>"+i);
}
}
}rab、tor、for会同时运行
静态代理
- 继承 Thread类方式的缺点：如果类已经从一个类继承，则无法再继承Thread类
- 通过 Runnable接口实现多线程（静态代理）
- 优点：可以同时实现继承。实现 Runnable接口方式要通用一些
- 1.避免单继承
- 2.方便共享资源同一份资源多个代理访问
静态代理：类是固定的
动态代理：类是动态创建
eg:
/**
* 静态代理设计模式
* 1.真实角色
* 2.代理角色:持有真实角色的引用
* 3.二者实现相同的接口
* @author qiao39gs
*
*/
public class StaticProxy {
public static void main(String[] args) {
//创建真实角色
Marry you = new You();
//创建代理角色+真实角色的引用
WeddingCompany company = new WeddingCompany(you);
//执行任务
company.marry();
}
}
//接口
interface Marry{
void marry();
}
//真实角色
class You implements Marry{
@Override
public void marry() {
System.out.println("`````````");
}
}
//代理角色
class WeddingCompany implements Marry{
private Marry you;
public WeddingCompany() {
}
public WeddingCompany(Marry you) {
super();
this.you = you;
}
private void before(){
System.out.println("11111");
}
private void after(){
System.out.println("33333");
}
@Override
public void marry() {
before();
you.marry();
after();
}
}方法二：runable+静态代理实现多线程
一、继承 Thread+run()
启动：创建子类对象+对象.start()
二、实现 Runnable+run()
启动：使用静态代理
1、创建真实角色
2、创建代理角色 Thread+引用
3、代理角色 start()
推荐 Rannable 创建线程
1.避免单继承的局限性
2.便于共享资源
eg1:
/**
* 使用 Runnable 创建线程
* 1.类 实现 Runnable接口+重写 run() —— 真实角色类
* 2.启动多线程，使用静态代理
* 1.创建真实角色
* 2.创建代理角色+真实角色引用
* 3.调用.start()启动线程
* @author qiao39gs
*
*/
public class Programmer implements Runnable {
public void run(){
for (int i = 0; i < 1000; i++) {
System.out.println("一边敲代码");
}
}
}public class ProgrammerApp {
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("一边喝水");
}
}
}eg2:
/**
* 方便共享资源
* @author qiao39gs
*
*/
public class Web123456 implements Runnable{
private int num = 50;
@Override
public void run() {
while(true){
if(num<0){
break;
}
System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
}
}
public static void main(String[] args) {
//真实角色
Web123456 web = new Web123456();
//代理
Thread t1 = new Thread(web,"路人甲");
Thread t2 = new Thread(web,"黄牛乙");
Thread t3 = new Thread(web,"黄牛丙");
//启动线程
t1.start();
t2.start();
t3.start();
}
}方法三：通过Callable接口实现多线程
优点：可以获取返回值
- Callable和 Future接口
- Callable是类似于 Runnable的接囗，实现 Callable接囗的类和实现 Runnable的类都是可被其它线程执行的任务
- Callable和 Runnable有几点不同：
- Callable规定的方法是call()，而 Runnab规定的方法是run()
- call()方法可抛出异常，而run()方法是不能抛出异常的
- Callable的任务执行后可返回值，运行 Callable任务可拿到一个 Future对象，而 Runnable的任务是不能返回值的
- Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果
- 通过 Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
缺点：繁琐
思路
- 创建 Callable实现类+重写call
- 借助执行调度服务 ExecutorService，获取 Future对象
ExecutorService ser = Executors.newFixedThreadPool(2);
Future result = ser.submit(实现类对象); - 获取值 result.get()
- 停止服务 ser.shutdownNow();
eg:龟兔赛跑
/**
* 使用Callable创建线程
* @author qiao39gs
*
*/
public class Call {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建线程
ExecutorService ser = Executors.newFixedThreadPool(1);
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; //步
public Race() {
super();
// TODO Auto-generated constructor stub
}
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 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;
}
}
617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
