线程状态：
1. 新建状态（New）：新创建了一个线程对象。
2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5. 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
实现Runnable接口比继承Thread类更有优势：
1.因为java只能单继承，实现Runnable接口可以避免单继承的局限性
2.继承Thread类，多个线程不能处理或者共享同一个资源，但是实现Runnable接口可以处理同一个资源。
public class TicketsThread extends Thread{
//用静态变量存放这100张票，这样就不会卖重复
private int tickets = 100;
public void run(){
while(true){
if(tickets > 0){
System.out.println(Thread.currentThread().getName()+"***sale***"+(--tickets));
}
}
}
/**
* @param args
*/
public static void main(String[] args) {
// 不合理的买票程序，因为，不同线程都可以卖同一张票，
//现实生活中不是这样的，窗口1买完第99张票，窗口2不可以卖了。
TicketsThread t1 = new TicketsThread();
TicketsThread t2 = new TicketsThread();
TicketsThread t3 = new TicketsThread();
t1.start();
t2.start();
t3.start();
}
}
为什么要将Runnable接口子类的对象传递给Thread类的构造方法？
因为线程的任务（要运行的代码）都封装在Runnable接口的子类对象的run方法中，所以在线程对象创建的时候就必须明确要运行的任务。
public class TicketsRunnable implements Runnable {
private int ticket=100;
//Object obj = new Object();
public TicketsRunnable(){
System.out.println("*****************************");
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
//synchronized(obj){ //同步代码块
if(ticket > 0){//当线程0被调起的时候，当执行到这条判断语句的时候，线程1被调起抢了CPU资源，线程0进入冻结状态。
try {
Thread.sleep(100);//中断当前活跃的线程，或者执行的线程
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖票"+ticket--);
//System.out.println(Thread.currentThread().getId());
//System.out.println(Thread.currentThread().getName());
}
//}
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TicketsRunnable runna = new TicketsRunnable();
Thread t1 = new Thread(runna);
Thread t2 = new Thread(runna);
Thread t3 = new Thread(runna);
t1.start();
t2.start();
t3.start();
}
}
分析：当100张票卖到剩余最后1张的时候，也就是ticket=1的时候，有三个线程Thread-0，Thread-1，Thread-2，这时候，Thread-0进入if（ticket > 0）这个条件具备了执行资格，但不具备执行权。正在这个时候，CPU切换到了Thread-1，Thread-1也进入了if（ticket > 0）这个条件下面，CPU又切换到了Thread-2，Thread-2又进入阻塞状态。这个时候三个线程都通过了if（ticket > 0）判断，都要往下执行了，这个时候CPU的资源被Thread-0第一个线程抢到，执行ticket=1，ticket--，那么第一个线程执行完打印出ticket=1，CPU被Thread-2抢到，打印出ticket=0，同理线程3执行完打印出ticket=-1，这就出现了线程安全的问题。
通过上面的分析大家知道了多线程安全产生的原因：当多条语句（if(ticket>0)和ticket--）在操作同一个线程的共享数据的时候（这里共享数据为ticket=100），一个线程执行了多条语句的一部分，还没有执行完，另一个线程抢到CPU资源，执行。导致数据共享错误。那么怎么解决呢？
解决办法：当多条语句在操作共享数据时，只能让一个线程执行完，在执行的过程中，其它线程不可以参与执行。java对于多线程安全问题，提供了专业的解决方法，那就是锁。
synchronized(对象){
需要被同步的代码
}
public class TicketsRunnable implements Runnable {
private int ticket=100;
Object obj = new Object();//对象锁，共同步代码块使用
public TicketsRunnable(){
System.out.println("*****************************");
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
synchronized(obj){ //同步代码块
if(ticket > 0){//当线程0被调起的时候，当执行到这条判断语句的时候，线程1被调起抢了CPU资源，线程0进入冻结状态。
try {
Thread.sleep(100);//中断当前活跃的线程，或者执行的线程
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖票"+ticket--);
//System.out.println(Thread.currentThread().getId());
//System.out.println(Thread.currentThread().getName());
}
}
}
}
/**
* @param args
*/
public static void main(String[] args) {
TicketsRunnable runna = new TicketsRunnable();
Thread t1 = new Thread(runna);
Thread t2 = new Thread(runna);
Thread t3 = new Thread(runna);
t1.start();
t2.start();
t3.start();
}
}
多线程：生产者消费者模型
1.wait和notify，notifyAll：
wait和notify，notifyAll是Object类方法，因为等待和唤醒必须是同一个锁，不可以对不同锁中的线程进行唤醒，而锁可以是任意对象，所以可以被任意对象调用的方法，定义在Object基类中。
wait()方法：对此对象调用wait方法导致本线程放弃对象锁，让线程处于冻结状态，进入等待线程的线程池当中。wait是指已经进入同步锁的线程，让自己暂时让出同步锁，以便使其他正在等待此锁的线程可以进入同步锁并运行，只有其它线程调用notify方法或者notifyAll方法后，才能唤醒线程池中等待的线程。
notify()方法：唤醒线程池中的任意一个线程。
notifyAll方法：唤醒线程池中的所有线程
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class Resource {
private boolean flag = false;
private int num;
Object object = new Object();
public void product() {
synchronized (object) {//同步锁可以是this,类字节码，等 但是对应的调用锁对象的wait() notify()方法
while (flag) { //每次判断避免生产者唤醒生产者然后多次生产不消费
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " product " + ++num);
flag = true;
object.notifyAll();//不用notify 避免只剩两个生产者时一个生产后等待唤醒另外一个生产者继续等待后出现的生产者消费者都处于等待状态
}
}
public void consume() {
synchronized (object) {
while (!flag) {
try {
synchronized (Resource.class) {
object.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " consume " + num);
flag = false;
object.notifyAll();
}
}
}
public class Consumer implements Runnable {
private Resource resource;
public Consumer(Resource resource) {
this.resource = resource;
}
@Override
public void run() {
while (true) {
resource.consume();
}
}
}
public class Product implements Runnable {
private Resource resource;
public Product(Resource resource) {
this.resource = resource;
}
@Override
public void run() {
while (true) {
resource.product();
}
}
}
@Test
public void testProCon() {
Resource resource = new Resource();
Product product = new Product(resource);
Product product2 = new Product(resource);
Consumer consumer = new Consumer(resource);
Consumer consumer2 = new Consumer(resource);
new Thread(product).start();
new Thread(product2).start();
new Thread(consumer).start();
new Thread(consumer2).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}