一、程序、进程、线程
1.程序：程序就是我们编写的代码，也就是指令集，是一个静态概念。
2.进程：操作系统调度我们的程序，动态概念，一个程序就是一个进程。进程是程序的一次动态执行过程，占用特定的地址空间，每个进程是独立的，由3部分组成：cpu,data(数据)，code(代码区)。缺点：内存浪费，cpu会有负担。
3.线程：是进程中的一个单一的执行路径，线程又被称为轻量级的进程。一个进程可以拥有多个并行的线程。一个进程中的线程共享内存单元/内存地址空间，多个线程可以共享数据，可以访问相同的变量和对象，是从同一堆中分配对象。所以有一个并发的问题，一份数据多个线程来用。由于线程间的通信是在同一地址空间进行，所以不需要额外的通信机制，
一个程序就有一个进程，每个进程有独立的代码和数据空间，进程间的切换有较大的开销。
多进程是操作系统能同时运行多个任务（程序），多线程是在同一应用程序中有多个执行流程。
系统为每个进程分配不同的内存区域，不会为线程分配内存（因为线程在进程中），线程是进程的一部分，所以线程也被成为轻量级进程。
线程在java中也是类和接口，进程包含线程，线程是进程的一部分，线程是不同的执行路径，
多线程就是有多核，多个cpu。cpu有一个调度，有一个时间片，时间片非常的小。main方法是一个主线程，就是一条路径。
线程创建的第一种方式：
/**
* 模拟龟兔赛跑
1、创建多线程 继承 Thread +重写run(线程体)
2、使用线程: 创建子类对象 + 对象.start() 线程启动
*/
public class Rabbit extends Thread {
@Override
public void run() {//线程体，一切从run开始就像main方法一切从main开始，这个运行一切从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) {//main也是一个线程有自己的路径。
//创建子类对象
Rabbit rab = new Rabbit();
Tortoise tor =new Tortoise();
//调用start 方法，内部由cpu调用他们，start()只是加到线程里面。
rab.start();
//rab.run();//不要调用run方法，调用run方法不是启动线程而是普通方法的调用。程序会从上到下依次调用执行。
tor.start();
//tor.run();
for(int i=0;i<100;i++){
System.out.println("main==>"+i);
}
/*main==>96
main==>97
main==>98
main==>99
乌龟跑了0步
乌龟跑了1步
乌龟跑了2步
兔子跑了14步
兔子跑了15步
兔子跑了16步
兔子跑了17步*/
}//rab.start(); 和 tor.start();和 main()的for(int i=0;i<100;i++){System.out.println("main==>"+i);}3者交替执行
}
第二种实现多线程的方式：
继承Thread类方式的缺点是如果一个类已经从另一个类继承则无法再继承Thread类。
所以通过实现Runnable接口，有点是可以实现同时继承。
Runnable接口用到了静态代理设计模式,下面先看看静态代理设计模式。
/**
* 静态代理 设计模式（静态代理的时候WeddingCompany是写死的，动态代理的时候WeddingCompany是动态创建的，也就是说代理对象是动态的）（代理就是代别人做事，被代理就是别人做事都是做的自己的事）
* 代理的要求：
* 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{
void 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();
}
}
静态代理 + Runnable接口实现多线程：
/**
推荐 Runnable 创建线程
1)、避免单继承的局限性（继承接口后还可以继承其他类）
2)、便于共享资源
使用 Runnable 创建线程
1、类 实现 Runnable接口 +重写 run() --> 真实角色类
2、启动多线程 使用静态代理
1)、创建真实角色
2)、创建代理角色 +真实角色引用
3)、调用 .start() 启动线程
*/
public class Programmer implements Runnable {
@Override
public void run() {
for(int i=0;i<1000;i++){
System.out.println("一边敲helloworld....");
}
}
}
public class ProgrammerApp {
public static void main(String[] args) {//main也是一个线程有自己的路径。
//1)、创建真实角色
Programmer pro =new Programmer();
//2)、创建代理角色 +真实角色引用
Thread proxy =new Thread(pro);//Thread和Programmer一样实现了Runnable接口，proxy代理别人做事，所以proxy是代理，Programmer是被代理。所以这里用到了静态代理模式。
//3)、调用 .start() 启动线程
proxy.start();
for(int i=0;i<1000;i++){
System.out.println("一边聊qq....");
}
}
}
/**
* 方便共享资源
*/
public class Web12306 implements Runnable {
private int num =10;//50张票
@Override
public void run() {
while(true){
if(num<=0){
break; //跳出循环
}
System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
}
}
public static void main(String[] args) {//这个线程的名字是main
//真实角色
Web12306 web = new Web12306();
//public class Thread implements Runnable {}
//静态代理模式，Thread和Web12306都实现了Runnable接口，
// public Thread(Runnable target, String name) {}
Thread t1 =new Thread(web,"路人甲");//线程t1的名字
Thread t2 =new Thread(web,"黄牛已");//线程t2的名字
Thread t3 =new Thread(web,"攻城师");//线程t3的名字
//启动线程
t1.start();//start()就启动了线程
t2.start();
t3.start();
/*路人甲抢到了9
黄牛已抢到了10
黄牛已抢到了8
黄牛已抢到了7
黄牛已抢到了6
黄牛已抢到了5
黄牛已抢到了3
黄牛已抢到了2
黄牛已抢到了1
攻城师抢到了4*/
}
}
线程：
一、继承Thread,重写run()方法，启动：创建子类对象+对象.start()
二、实现Runnable，重写run(),启动：使用静态代理，1.创建真实角色，2.创建代理角色（Thread），3.代理角色.start()
实现Runnable，重写run()的缺点是不能拋异常，没有返回值，因此使用Callable接口解决这个问题。使用Callable创建线程比较繁琐，优点是又返回值并且可以对外申明异常。
通过Callable接口实现多线程
优点：可以获取返回值
Callable和Future接口，Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable接口的类都是可被其他线程执行的任务。
Callable和Runnable有几点不同：
1.Callable规定的方法是call(),而Runnable规定的方法是run()
2.call()可抛出异常，而run()是不能抛出异常的
3.Callable的任务执行后可返回值，运行Callable任务可以拿到一个Future对象，而Runnable任务是不能返回值的，Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行的情况，可取消任务的执行，还可以获取任务的执行结果。
缺点：繁琐
步骤：
1.创建Callable实现类，重写call方法。
2.借助执行调度服务ExecutorService获取Future对象。
ExecutorService ser=Executors.newFixedThreadPool(2);
Future result =ser.submit(实现类对象) ;
3.获取值result.get();
4.停止服务ser.shutdownNow();
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 {
//创建2个线程
ExecutorService ser=Executors.newFixedThreadPool(2);
Race tortoise = new Race("老不死",1000);
Future<Integer> result1 =ser.submit(tortoise) ;//让线程执行tortoise，获取值，
tortoise.setFlag(false); //停止线程体循环
int num1 =result1.get();//进入call方法
System.out.println("乌龟跑了-->"+num1+"步");
Race rabbit = new Race("小兔子",500);
Future<Integer> result2 =ser.submit(rabbit) ;
rabbit.setFlag(false);
int num2 =result2.get();
System.out.println("小兔子跑了-->"+num2+"步");
Thread.sleep(2000); //2秒
ser.shutdownNow();//停止服务
}
}
class Race implements Callable<Integer>{//继承Callable接口，重写call方法。
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;
}
}
线程的状态：
1.线程创建。
2.调用start()方法，线程进入就绪状态。
3.cpu调度，线程进入运行状态。
4.任务完成，线程终止。
5.线程运行过程中，出现导致阻塞的事件，线程进入阻塞状态，阻塞解除后，线程又进入就绪状态。（阻塞接触后是进入就绪状态不是运行状态）。
线程干涉：
线程体通过标示符，外部通过条件调用。
public class StopDemo01 {
public static void main(String[] args) {
Study s =new Study();
new Thread(s).start();
//外部干涉
for(int i=0;i<100;i++){
if(50==i){ //外部干涉
s.stop();
}
System.out.println("main.....-->"+i);
}
}
}
class Study implements Runnable{
//1)、线程类中 定义 线程体使用的标识
private boolean flag =true;
@Override
public void run() {
//2)、线程体使用该标识
while(flag){
System.out.println("study thread....");
}
}
//3)、对外提供方法改变标识
public void stop(){
this.flag =false;
}
}
阻塞：
1.join:合并线程。
2.yeld:暂停自己，让别的线程执行。
3.sleep:休眠,休眠的时候不会释放锁。常用于与时间相关的和模拟网络延时。
/**
* join:合并线程
*/
public class JoinDemo01 extends Thread {
public static void main(String[] args) throws InterruptedException {
JoinDemo01 demo = new JoinDemo01();
Thread t = new Thread(demo); //新生
t.start();//就绪
//cpu调度 运行
for(int i=0;i<1000;i++){
if(50==i){
t.join(); //main阻塞...一定要等到t的线程执行完main才能开始执行。
}
System.out.println("main...."+i);
}
}
@Override
public void run() {
for(int i=0;i<1000;i++){
System.out.println("join...."+i);
}
}
}
public class YieldDemo01 extends Thread {
public static void main(String[] args) {
YieldDemo01 demo = new YieldDemo01();
Thread t = new Thread(demo); //新生
t.start();//就绪
//cpu调度 运行
for(int i=0;i<1000;i++){
if(i%20==0){
//暂停本线程 main，yield是一个静态方法，写在哪个线程体里面就暂停谁。之后什么时候再次调用是由cpu的调度算法决定的。
Thread.yield();
}
System.out.println("main...."+i);
}
}
@Override
public void run() {
for(int i=0;i<1000;i++){
System.out.println("yield...."+i);
}
}
}
/**
* 倒计时
* 1、倒数10个数，一秒内打印一个
* 2、倒计时
*/
public class SleepDemo01 {
public static void main(String[] args) throws InterruptedException {
Date endTime =new Date(System.currentTimeMillis()+10*1000);//当前时间加上10秒
long end =endTime.getTime();
while(true){
//输出
System.out.println(new SimpleDateFormat("mm:ss").format(endTime));
//等待一秒
Thread.sleep(1000);
//构建下一秒时间
endTime =new Date(endTime.getTime()-1000);
//10秒以内 继续 否则 退出
if(end-10000>endTime.getTime()){
break;
}
}
/*17:56 17:55 17:54 17:53 17:52 17:51 17:50 17:49 17:48 17:47 17:46*/
}
public static void test1() throws InterruptedException{
int num =10;
while(true){
System.out.println(num--);
Thread.sleep(1000); //暂停
if(num<=0){
break;
}
}
}
}
/**
* Sleep模拟 网络延时 线程不安全的类
*/
public class SleepDemo02 {
public static void main(String[] args) {
//真实角色
Web12306 web= new Web12306();
Web12306 web2 = new Web12306();
//3个代理同时操控一个被代理对象，
Thread t1 =new Thread(web,"路人甲");
Thread t2 =new Thread(web,"黄牛已");
Thread t3 =new Thread(web,"攻城师");
//启动线程
t1.start();
t2.start();
t3.start();
}
}
class Web12306 implements Runnable {
private int num =50;
@Override
public void run() {
while(true){
if(num<=0){//num=1时，当a、b、c依次进来后依次开始睡眠。
break; //跳出循环
}
try {
Thread.sleep(5000);///sleep也是暂停线程的一种方式.休眠的时候不会释放锁，
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"抢到了"+num--);
}//a醒了以后带走了1，b醒了以后带走了0，c醒了以后带走了-1。
}
}
