多线程
线程的五个状态新建，就绪，执行，等待，销毁
- 新建线程需要调用
start()方法才会进入就绪状态 - 处于就绪状态的线程并不一定立即被执行，而是听从CPU调度，即将被执行，所以被称为就绪
- 处于等待状态的线程不会被CPU调度
如何创建新的线程
方法一
public class TestThread extends Thread {
//默认构造方法
public TestThread(){}
//传入的String参数为线程名称
public TestThread(String name) {
super(name);
}
//该方法在线程由就绪转为执行时被调用
@Override
public void run() {
super.run();
System.out.println(this.getName());
}
}
这样我们已经声明了自己的线程类，对于不同的线程，他们的区别主要在于他们的run()方法内的业务逻辑不同，同时我们需要注意的是，我们还没有实例化对象，也就是说现在新的线程还没有被创建.
public static void main(String[] args) {
TestThread thread1 = new TestThread("新线程");
thread1.start();
}
只有当线程对象的start()方法被调用时，该线程才真正进入就绪状态，等待CPU调度，进入执行状态.
方法二
//实例化runnable对象
TestRunnable runnable = new TestRunnable();
//实例化Thread对象，将runnable对象作为参数
Thread thread2 = new Thread(runnable);
thread2.start();
当我们去自定义自己的Thread时候，我们只是希望重写它的run()方法内的业务逻辑，所以我们可以实例化 Runnable 对象，作为 Thread 的构造参数. 使用Runnable 我们可以避免单继承的问题
这实际上是一种静态代理的设计模式
状态切换及相关方法
join:类方法，使调用该方法的线程进入就绪状态，阻塞其它线程，直到该线程执行完毕
yield:Thread 静态方法, 在哪个线程中调用，就使那个线程进入就绪状态，等待 cpu 调度
sleep:Thread 静态方法，与 yield 相比可以指定时间不会让出锁，多用于倒计时或模拟网络延时
currentThread:Thread 静态方法，在哪个线程中调用就返回哪个线程的引用
setPriority: MAX_PRIORITY -> 10, MIN_PRIORITY -> 1, NORM_PRRIORITY -> 0 优先级高的线程不能保证一定先执行，只是抢占资源时几率大一些，是否执行要服从 cpu 的调度
public static void main(String[] args) throws InterruptedException {
/**
* 控制台会交替输出 1 和 2
* 实际上多线程在很多情况下不是真正的并行
* 而是 cpu 在极短的时间内不断切换线程来达到异步的效果
*/
Thread t1 = new Thread() {
@Override
public void run() {
super.run();
int i = 1010;
while (i-- > 0)
System.out.println("1");
}
};
Thread t2 = new Thread() {
@Override
public void run() {
super.run();
int i = 1010;
while (i-- > 0)
System.out.println("2");
}
};
t1.start();
t2.start();
}
当我们运行如下代码，就会发现所有的 2 会在 1 输出之后
t1.start();
t1.join();
t2.start();
下面的代码输出会出现同样的结果，因为我们在线程2中调用了静态方法 sleep，并且 1000ms 是一个足够让 t1 完成输出的时间
Thread t2 = new Thread() {
@Override
public void run() {
super.run();
int i = 1010;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
while (i-- > 0)
System.out.println("2");
}
};
锁
进程：资源分配的单位，进程间切换会有较大的开销
线程：调度和执行的单位，线程间切换开销较小，但是线程仍然具有独立的运行栈和计数器（PC）
多线程会涉及到并发问题，因为线程之间共享数据内存单元，内存地址，可以访问相同的变量和对象。而且该问题在无论是否是真正的并行条件下都出现.
下面的代码的输出结果为三个人都抢到了这台手机, 这就出现了多线程的中的并发问题，同时 MI 类中的 buy() 方法也被称为是线程不安全的
class MI {
private int MIX3 = 1;
public boolean buy() throws InterruptedException {
if (MIX3 > 0) {
Thread.sleep(1000);//模拟交接手续耗时
MIX3--;
System.out.println("抢到了");
return true;
} else {
System.out.println("没货了");
return false;
}
}
}
public static void main(String[] args) {
MI mi = new MI();
Runnable buy = new Runnable() {
@Override
public void run() {
try {
mi.buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread t1 = new Thread(buy);
Thread t2 = new Thread(buy);
Thread t3 = new Thread(buy);
t1.start();
t2.start();
t3.start();
}
我们可以通过在方法前加上synchronized关键字来是一个线程不安全的方法变为同步方法，当然安全就意味着效率的损失，所以我们也可以用同步块，仅使一部分代码变为同步
- 同步块
synchronized(引用类型){
注意作为锁的对象要保证引用不变，即为同一个对象
} - 同步方法
静态代理
- 真实角色
- 代理角色（持有真实角色的引用）
- 二者实现相同的接口
比如当你结婚时，婚庆公司可以作为一个代理角色，帮助你结婚，但真正结婚的仍然是你，也就是说你是真实角色，而婚庆公司是代理角色，静态代理的好处就是，作为真实角色的你只需要关注最核心的事，也就是‘结婚’，其它的工作都可以交由代理角色处理
public class Main {
public static void main(String[] args) {
You you = new You();//真实对象
ProxyCompany proxy = new ProxyCompany(you);//代理对象
proxy.merry();
}
}
/**
*二者要实现的相同的接口
*/
interface Merry {
void merry();
}
class You implements Merry {
@Override
public void merry() {
System.out.println("你和嫦娥结婚了");
}
}
class ProxyCompany implements Merry {
You you;//代理对象要持有真实对象引用
public ProxyCompany() {
}
public ProxyCompany(You you) {
this.you = you;
}
@Override
public void merry() {
before();
you.merry();
after();
}
private void before(){
System.out.println("布置猪窝");
}
private void after(){
System.out.println("闹猪窝");
}
}
而动态代理模式唯一的区别就是代理类是在运行过程中动态创建的，实现的功能是一样的
至于为什么要讲静态代理模式，不难发现 Runnable 即为真实对象和代理对象同时实现的接口，Thread 为代理类, Thread 构造方法传入的参数即为真实对象.
