JAVA学习笔记49——线程概念+进程、线程区别+创建进程三种方法

最近在看JAVA教学的视频，觉得老师讲的很好，同时借用源代码还有笔记来撰写本系列博客，记录自己的学习内容，同时也供看到的人学习。

本篇开始讲线程，先来介绍一下程序、进程、线程的概念，其实学过《操作系统》的童鞋应该都不陌生了：

1、程序:指令集 静态概念。2、进程:操作系统 调度程序 动态概念。3、线程:在进程内多条执行路径（在单核CPU下其实是一个虚拟、模拟的过程，真正的多线程是在多个CPU的前提下进行的）



再来看看进程、线程的具体区别总结;



接下来，介绍线程创建的三种方法：

NO.1：通过继承来实现多线程：下图所示，注：继承自Thread的类运行的入口时run方法而不再是main方法。



示例代码：

<span style="font-size:14px;">package com.bjsxt.thread.create;
/**
* 模拟龟兔赛跑
1、创建多线程  继承  Thread  +重写run(线程体)
2、使用线程: 创建子类对象 + 对象.start()  线程启动
*/
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+"步");
}
}
}</span>

<span style="font-size:14px;">import com.bjsxt.thread.create.Rabbit;

public class RabbitApp {
public static void main(String[] args) {
//第一步：创建子类对象
Rabbit rab = new Rabbit();
Tortoise tor =new Tortoise();

//第二步：为了开辟多条路径应该调用start 方法，之后经由CPU自主掌控(建议使用)；如果是让各个线程有序执行则调用run方法（不建议使用）
rab.start();
//rab.run();
tor.start();
//tor.run();
for(int i=0;i<1000;i++){
System.out.println("main==>"+i);
}
}
}
</span>

NO.2：通过实现Runnable接口来实现多线程：下图所示：



下面这段代码介绍的是一种“静态代理”思想的示例代码，具体的解释说明在代码的注释部分中：

<span style="font-size:14px;">/**
* 静态代理 设计模式
* 1、真实角色
* 2、代理角色： 持有真实角色的引用
* 3、二者 实现相同的接口
*/
public class StaticProxy {
public static void main(String[] args) {
//创建真实角色
Marry you =new You();
//创建代理角色 +真实角色的引用
WeddingCompany 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  XX结婚了....");
}
}

//代理角色
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();
}
}</span>

NO.3：通过实现Callable接口来实现多线程：下图所示：



实例代码：

<span style="font-size:14px;">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创建线程
*/
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<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() {
}

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;
}
}</span>