1.线程与进程的概念与区别
线程是轻量级的进程，线程是进程中的多条路径；
进程比较占用内存，线程是不同的执行路径；
mian 方法也是一个线程 我们把他称为主线程；
2.多线程的模拟（龟兔赛跑的例子）
创建多线程：
1、创建多线程 继承 Thread +重写run(线程体)
2、使用线程: 创建子类对象 + 对象.start() 线程启动
package Creat;
/**
*
* 我们来使用多线程来模拟龟兔赛跑的过程
*
* 1、创建多线程 继承 Thread +重写run(线程体)
* 2、使用线程: 创建子类对象 + 对象.start() 线程启动
*
* @author Wang
*
*/
public class Rabbit extends Thread{
public void run() {//重写Thread中的run（） 方法 这里就是线程体
for(int i=0;i<10;i++) {
System.out.println("兔子跑了" + i + "步" );
}
}
}
class Tortoise extends Thread{
public void run() {
for(int i=0;i<10;i++) {
System.out.println("乌龟跑了" + i + "步");
}
}
}
package Creat;
/**
*
* 对龟兔赛跑类的应用
* 1、创建多线程 继承 Thread +重写run(线程体)
* 2、使用线程: 创建子类对象 + 对象.start() 线程启动
*
* @author Wang
*
*/
public class RabbitApply {
public static void main(String[] args) {
Rabbit rab = new Rabbit();
Tortoise tor = new Tortoise();
tor.start();//这样就等于创建了多线程 创建了两条赛道 加上main（） 这个主线程那么就是三个赛到了
rab.start(); // 启动多线程是调用start方法而不能调用run（）方法
for(int i=0;i<10;i++) {//这样就是三个线程同时运行了
System.out.println("main走了" + i + "步");
}
}
}
我们的多线程体现在他们跑的时候是同时跑的 如果不是多线程的话 那么就是一个跑完 一个再跑；
3.静态代理设计模式：
package StaticProxy;
/**
*
* 静态代理的设计模式
* 1、要有真实角色
* 2、要有代理角色： 持有真实角色的引用
* 3、二者 实现相同的接口
*
* 我们用这个设计模式 来模拟婚庆公司来代理猪八戒的婚礼的过程
*
* @author Wang
*
*/
public class StaticProxy {
public static void main(String[] args) {//我们在这里来对我们的代理模式来进行应用
Pigsy pig = new Pigsy();//创建一个实体对象猪八戒
WeddingCompany com = new WeddingCompany(pig);//创建一个代理对象 把你的实体对象穿进去 去结婚
com.marry();//这样八戒与嫦娥的回力就完善了 结婚的人还是八戒
}
}
interface Marry{
void marry();//因为是接口 所以这里相当于 public abstract void marry（）；
}
class Pigsy implements Marry {// 我们在这里创建一个实体 供婚庆公司代理用
@Override
public void marry() {
System.out.println("Pigsy marry with 嫦娥");
}
}
class WeddingCompany implements Marry{// 这里我们要求代理公司与实体实现同一个接口
private Marry pig;//代理要有实体对象的引用
public WeddingCompany(Marry pig) {
this.pig = pig;
}
private void before() { //代理的作用就是有一些你没有的方法 他来帮你完成 你只需要把自己传进进来就好了
System.out.println("布置猪窝");
}
private void after() {
System.out.println("闹洞房");
}
@Override
public void marry() {
before();
pig.marry();
after();
}
}
其实Thread类也就是一个代理商，就是这个代理商已经为我们写好了；
Thread实现了Runnable这个接口；
我们要使用静态代理设计模式那么我们也只要实现Runnable这个接口，再把我们的实体对象传进去就行了；
这里是另外一种实现多线程的方法；
还有就是要重写一下Runnable这个接口里的run方法；
这里是持有真实对象的引用；
4.使用Runnable来创建多线程（这里用的就是staticProxy的设计模式）
使用它的好处：
1.避免单继承的局限性
2.便于共享资源
两种主要的实现多线程的方法：
package Runnable;
/**
*
* 我们来用多线程来实现抢票的过程
*
* @author Wang
*
*/
public class Web implements Runnable{
private int ticketNum = 500;
@Override
public void run() {
while(true) {
if(ticketNum<0) {
break;
}
System.out.println(Thread.currentThread().getName() + "抢到了" + ticketNum--);
}
}
public static void main(String[] args) {
Web web = new Web();//创建实体对象
Thread thr1 = new Thread(web,"路人甲");//创建四个代理 他们来实现多线程的抢票
Thread thr2 = new Thread(web,"黄牛");
Thread thr3 = new Thread(web,"程序员");
Thread thr4 = new Thread(web,"白领");
thr1.start();
thr4.start();
thr2.start();
thr3.start();
}
}