一、多线程
进程：正在进行中的程序（直译）
线程：就是进程中控制程序执行的一个控制单元（执行路径）。
一个进程中可以有多个执行路径，称为多线程。
多线程的好处：解决了多个部分同时运行的问题。
多线程的缺点：线程太多后效率低下。
JVM运行的时候至少有两个线程：
1.主线程，执行main函数
2.负责垃圾回收
创建新执行线程有两种方法：
1.将类声明为Thread的子类，该子类应重写Thread类的run方法。接下来可以分配并启动该子类的实例。
但是直接在主线程中调用线程类的run方法，并不能执行该线程，只相当于在主线程中new该线程类，仍然处于主线程内。要想创建并启动一个线程，在new该线程类后，用start()方法启动该线程。
如：
class Demo extends Thread { void run() { } } class Zu { public static void main(String [] args) { Demo d=new Demo(); d.start(); } }
线程的四种状态：
有一种特殊的状态：就绪。具备了执行资格，但是还没有获取资源。
CPU的执行资格：可以被CPU处理，在执行队列中排队。
CPU的执行权：正在被CPU处理。
所以，上图的运行状态为具备执行资格，同时具备执行权。冻结状态为不具备执行权，也不具备执行资格。如果具备了执行资格，但是沿未具备执行权，则为就绪状态。
2.实现Runable接口
在Runnable的子类中实现run方法，通过Thread类的创建线程对象，并将Runnable接口的子类对象作为Thread类线程对象构造函数的参数传入，最后调用线程对象的start()启动线程。
如：
class Demo implements Runnable { void run() { } } class Zu { public static void main(String [] args) { Demo d=new Demo(); Thread th=new Thread(d); th.start(); } }
实现Runnable接口的好处：
1.将线程的任务从线程的子类中分离出来，进行单独的封装。按照面向对象的思想将任务封装成对象。
2.避免了Java单继承的局限性。
线程安全问题产生的原因：
1.多个线程在操作共享的数据。
2.操作共享数据的代码有多条
在Java中用同步代码块可以解决上述问题。
synchronized(对象锁)
{
需要同步的代码;
}
上述同步代码块中的对象是任意的，比如Object obj=new Object();中的obj
同步的优点：解决了线程的安全问题
同步的缺点：同步代码中有可能失去CPU执行权而等待，效率比较低。
同步的前提：必须是多个线程使用同一个对象锁。
对于一个函数也可以用同步锁。
public synchronized void add(int num)
{
……
}
同步函数的锁为函数所属的对象本身。
建议使用同步块，少用同步函数。
线程间通讯：
等待唤醒机制：
1.wait(); //让线程处于冻结状态，被wait的线程会被存储到线程池
2.notify(); //唤醒线程池中的一个线程（任意）
3.notifyall(); //唤醒线程池中的所有线程
注意：上述方法必须定义在同步中，因为这些方法都是操作线程状态的方法，必须要明确到底操作的是哪个锁上的线程。
为什么操作线程的方法wait、notify、notifyall定义在了Object类中？因为这些方法就是监视器的方法，监视器其实就是锁。锁可以是任意的对象，任意对象的调用方式一定定义在Object类中。
要注意的是 sleep和wait方法都会抛出异常，这些异常不能用throws向上抛，因为Runnable接口中未抛出异常，只能用try来处理异常。
多生产者、多消费者的问题（烤鸭问题）：
package test; class Duck { private int num=0; Boolean flag=false; public void set() { synchronized (this) { while (flag) { try { this.wait(); } catch(InterruptedException e) {} } num++; System.out.println("生产…………"+num); flag=true; notifyAll(); } } public void get() { synchronized (this) { while (!flag) { try { this.wait(); } catch(InterruptedException e) {} } System.out.println("消费………………"+num); flag=false; notifyAll(); } } } class Producer implements Runnable{ Duck duck; public Producer(Duck d) { this.duck=d; } @Override public void run() { while(true) { duck.set(); } } } class Consummer implements Runnable{ Duck duck; public Consummer(Duck d) { this.duck=d; } @Override public void run() { while(true) { duck.get(); } } } public class MyThread { public static void main(String[] args) { Duck duck=new Duck(); Thread t0=new Thread(new Producer(duck)); Thread t1=new Thread(new Producer(duck)); Thread t2=new Thread(new Consummer(duck)); Thread t3=new Thread(new Consummer(duck)); t0.start(); t1.start(); t2.start(); t3.start(); } }
if判断标记，只有一次，会导致不该运行的线程运行了，出现了数据错误的情况。
while判断标记，解决了线程获取执行权后，是否要运行！
notify只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致死锁。
notifyall解决了本方线程一定会唤醒对方线程。
wait和sleep的区别：
1.wait可以有时间参数，也可以没有
sleep一定有时间参数
2.wait释放CPU执行权，同时释放锁
sleep释放CPU执行权，但是不释放锁
在jdk1.5以后，将同步和锁封装成了对象，并将操作锁的方法定义到了该对象中，将隐式动作定义成了显示动作。常用lock接口对象代替同步代码块。
Lock lock=new ReentrantLock(); void show() {
try
{ lock.lock(); ……
}
finally
{ lock.unlock();
} }
Lock替代Synchronized，而Condition替代对象锁。一个Lock，可用newCondition方法生成多个Condition对象，每个Condition对象对应不同的wait,notify,notifyAll。在Condition对象中wait,notify,notifyAll对应为await、signal、signalAll。
例如上例的多生产者、多消费者的问题（烤鸭问题），用Lock接口写，代码如下：
package test; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class Duck { private int num=0; Boolean flag=false; Lock lock=new ReentrantLock(); Condition pro_lock=lock.newCondition(); Condition con_lock=lock.newCondition(); public void set() { lock.lock(); while (flag) { try { pro_lock.await(); } catch(InterruptedException e) {} } num++; System.out.println("生产…………"+num); flag=true; con_lock.signal(); lock.unlock(); } public void get() { lock.lock(); while (!flag) { try { con_lock.await(); } catch(InterruptedException e) {} } System.out.println("消费………………"+num); flag=false; pro_lock.signal(); lock.unlock(); } } class Producer implements Runnable{ Duck duck; public Producer(Duck d) { this.duck=d; } @Override public void run() { while(true) { duck.set(); } } } class Consummer implements Runnable{ Duck duck; public Consummer(Duck d) { this.duck=d; } @Override public void run() { while(true) { duck.get(); } } } public class MyThread { public static void main(String[] args) { Duck duck=new Duck(); Thread t0=new Thread(new Producer(duck)); Thread t1=new Thread(new Producer(duck)); Thread t2=new Thread(new Consummer(duck)); Thread t3=new Thread(new Consummer(duck)); t0.start(); t1.start(); t2.start(); t3.start(); } }
停止线程的方法：
1.stop方法
2.run方法
run方法一般都有循环，只要控制循环的次数就可以控制停止线程。
中断线程：interrupt 强制取消线程的冻结状态，让线程具备CPU执行资格。但是强制中断会发生中断异常。
线程对象的daemon方法，可以实现线程的前后台切换，当所有线程均为后台线程时，则程序结束。
线程对象的join方法，可以中止当前线程，执行join方法的线程对象，执行完后，当前线程才能重新获得CPU执行权。
Thread.yield方法可以暂停当前线程，继续执行其他的线程。
二、包（package）
注意点：
1.对类文件进行分类管理
2.给类提供多层命名空间
3.写在程序文件的第一行
4.类名的全称是：包名.类名
5.包也是一种封装形式
6.包在资源管理器中体现为文件夹
对象的权限：
public protected default private
同一个类中 ok ok ok ok
同一个包中 ok ok ok ok
子类中 ok ok
不同包中 ok