多线程
基础概念
多线程：
进程：一个程序中至少一个进程，一个进程至少一个线程。
用户线程，正常情况下创建
守护线程：需要手动创建
线程是通过调用start()方法准备启动
线程调度！
线程的创建方式：两种，
1.Thread类派生，覆盖run()
2.实现Runnable接口
线程调度
什么是线程调度？线程是不可控的，那么如何干预线程的执行？
-等待：
让某一个线程进入等待状态，等到条件满足后，被其他线程唤醒
等待需要在同步环境，未持锁则报错
等待后被唤醒，需重新经过持锁状态，然后回到就绪状态，等待资源分配
-休眠：
是让当前线程进入休眠状态，这是Thread的静态方法，休眠只能自己响
1.至少消耗指定时间，（等待资源分配）
2.休眠不可以被唤醒，休眠必须有参数！
-让步：
1.不建议使用优先级、礼让！因为最终结果不可控！
2.使用，先设优先级，再启动线程
3.让步是不可控的
4.没有经过阻塞，直接回到就绪状态
-合并线程：
1.是让并行线程，变为串行状态
2.先执行，再合并
3.什么情况下要合并线程？
某个线程要等到另外一个线程结果时，需要合并，已等待前面的结果。
-守护线程：（用户线程的区别--所有用户线程执行完毕后，其他所有守护线程killed）
1.当用户线程全部执行完毕后，守护线程立即停止，无论他执行到哪儿
2.守护线程，先设置，再执行。
应用情况：定时任务；清理日志；定时同步数据
-唤醒：一个对象可以持有多个锁吗？所以：线程之间争夺锁资源唯一
线程同步
1.同步（底层看不到）
同步方法:保护整个方法当中所有数据的安全
同步代码块：保护方法当中某个区域的数据安全，意义在于让那些不需要考虑到同步的数据先执行，以提高运行效率。
一般来说：属于线程本身数据区域的数据和 读的数据
2.非静态同步，同步的锁是对象锁，只有相同实例才存在同步
3.静态同步，锁的是类，只要是这个类，就会触发同步。
4.不建议大家混杂同时使用静态和非静态锁。
容器基本都是多线程！
内部封装好的安全类：
ByteArrayInputStream---FilterInputStream
StringBuffer
Collections
Note：
--即使是线程安全的类，也应该特别注意，因为操作的线程之间仍然不一定安全。
线程安全类的安全仅仅局限于：它本身，但是其他操作不一定！
基本概念：
死锁：--解决，按照预定义的顺序获取锁。
1.两个线程互相持有对方的锁，且互相等待，这种情况下，有小概率发生死锁。
2.避免死锁的策略，就是按照相同的顺序获取锁，并释放锁。原子化：
一个整体、数据完整
--要么都成功，要么都失败。
wait()\notify()\notifyAll()三个方法：
看下面的代码，这个代码执行的话会报错，java.lang.IllegalMonitorStateException
上网查了一下，明白了。
1>当前线程不含有当前对象的锁资源的时候，调用obj.wait()方法;
2>当前线程不含有当前对象的锁资源的时候，调用obj.notify()方法。
3>当前线程不含有当前对象的锁资源的时候，调用obj.notifyAll()方法。
生产消费者模型
生产消费者模型：
1.消息队列，服务发布和服务消费。。。。
消费者：
1.先来后到的顺序
2.消费者需要的东西，多种多样
3.消费者需要的东西，可以不需要一次性全部获取
4.如果生产者的能力达到上限，那么需要等待。
生产者：
1.生产者需要尽可能按照消费的先后顺序完成生产
2.生产者还必须保证所有的生产都要完成
3.如果没有消费者的消费需求，则需要等待。//定义队列对象（+泛型)
import java.util.LinkedList;
public class MyQueue<T> {
private LinkedList<T> queue;
private final int DEFAULT_CAPACITY = 20;
private int maxSize;
public MyQueue() {
this.maxSize = DEFAULT_CAPACITY;
this.queue = new LinkedList<T>();
}
public MyQueue(int size) {
this();
this.maxSize = size;
this.queue = new LinkedList<T>();
}
public synchronized void put(T t) {
if (queue.size()>=this.maxSize) {
System.out.println("队列已满...等待");
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
queue.add(t);
//唤醒的是当前对象wait()的线程
this.notifyAll();
}
public synchronized T get() {
if (queue.size()<=0) {
System.out.println("队列为空...等待");
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.notifyAll();
return queue.removeLast();
}
public synchronized int getSize() {
return this.queue.size();
}
}//生产者、消费者持有同一个线程对象
//生产线程
public class ProducerThread implements Runnable{
private final MyQueue q;
private final String message;
public ProducerThread(final MyQueue q,final String message){
this.q = q;
this.message = message;
}
@Override
public void run() {
//每隔2秒生产一个
while(true){
try {
Thread.sleep(500);
q.put(Thread.currentThread()+":"+message);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费者线程
public class ConsumerThread implements Runnable{
private final MyQueue q;
public ConsumerThread(final MyQueue q){
this.q = q;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
try {
Thread.sleep(1000);
Object obj = q.get();//消费
System.out.println(obj);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}//测试
public class Test {public static void main(String[] args) {
// TODO Auto-generated method stub
MyQueue q = new MyQueue();
//多生产者
new Thread(new ProducerThread(q, "生产者1")).start();
new Thread(new ProducerThread(q, "生产者2")).start();
new Thread(new ProducerThread(q, "生产者3")).start();
//多消费
new Thread(new ConsumerThread(q)).start();
new Thread(new ConsumerThread(q)).start();
new Thread(new ConsumerThread(q)).start();
}}
Volatile:关键字，不建议使用！
？？
有限的情形下使用volatile变量替代锁。
1.对变量的写操作不依赖于当前值。
final型的变量是禁止修改的，也就不存在线程安全的问题。
//继承自父类的属性，this.属性指向super.属性，都是指向父类的同一个属性(效果等效）
反射的应用
--Java.lang.reflect.*
应用：
1.反射调用方法———将方法作为对象，而不再是类名
2.field.setAccessible(true);--暴力更改访问机制，访问private
3.constructor.newInstance()
面向对象编程
开发期间：类是构成Java程序的单位，Java程序通过类来组织其结构
运行期间：对象是Java程序在运行时的单位，运行期间的Java程序是通过多个对象之间的相互作用关系来完成需求，动态。
null:空指针，内存地址的一个值，指空，不存在。
垃圾回收机制GC：是一个独立的巡查线程，GC是一个定时任务，隔一段时间执行一次。基本数据类型在栈内存中开辟空间，同时直接将具体数值（而不是地址）保存在栈中
--int numb = null;报错
引用类型在栈中开辟空间，同时在堆中开辟空间，创建对象，将对象地址保存在栈中。
内存模型，原理？
