线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的应用程序的空间标示，线程负责的是应用程序的执行顺序。
一个进程至少有一个线程在运行，当一个线程中出现多个线程时，就称这个应用程序是多线程应用程序。java虚拟机再启动时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。当产生垃圾时，收垃圾的动作，是不需要主线程来完成滴，因为主线程去收垃圾，主线程中的代码就会停止运行，效率很低，所以有单独的一个线程来负责垃圾的回收。
随机性的原理，因为cpu的快速切换，哪个线程获取到cpu的执行权，哪个线程就执行。
创建线程的方法之继承Thread
String getName() 返回该线程的名称。
void setName(String name) 改变线程名称，使之与参数 name 相同。
int getPriority() 返回线程的优先级。
void setPriority(int newPriority) 更改线程的优先级。
boolean isDaemon() 测试该线程是否为守护线程。
void setDaemon(boolean on) 将该线程标记为守护线程或用户线程。
static void sleep(long millis)
void interrupt() 中断线程。
static void yield() 暂停当前正在执行的线程对象，并执行其他线程。
void join() 等待该线程终止。临时加入一个线程的时候可以使用join方法。A线程执行到B线程的join方式时，A线程处于冻结状态，释放了执行权，B线程开始执行，A什么时候执行呢？只有当B线程运行结束后，A才从冻结状态恢复运行状态执行。
void run()
void start()
从Object类继承来的方法 void notify() void wait()
创建过程；
1.定义类继承Thread类
2.目的是复写run方法，将要让线程运行的代码都存储到run方法中。
3.通过创建Thread类的子类对象，创建线程对象；
4.调用线程的start方法，开启线程，并执行run方法。
package com.inphase.thread;
import java.util.Random;
public class RebPack extends Thread{
private static int redNum = 5 ;
public int getRedNum() {
return redNum;
}
public void setRedNum(int redNum) {
this.redNum = redNum;
}
//创建一个抢红包的线程
public void run(){
Random ra = new Random();
int i = ra.nextInt(10)+1;
while(redNum>0){
redNum--;
System.err.println(Thread.currentThread().getName()+"抢了"+i+"元");
try {
Thread.sleep(300);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
package com.inphase.thread;
/**
* 模拟抢红包过程，生成5个红包（金额是随机生成的，范围在1-10元之间）
* 创建5个线程代表5个人，然后让这5个人去抢这5个红包，每次抢红包需要300ms的时间，
* 在控制台打印出 （xxx抢了xxx元）
*（不限定每人抢的次数并且抢到红包后还可以接着抢，每次生成一个红包）
* @author Administrator
*
*/
public class RedTest {
public static void main(String[] args) {
RebPack redPack = new RebPack();
Thread redPack1 = new Thread(redPack);
redPack1.setName("张三");
Thread redPack2 = new Thread(redPack);
redPack2.setName("李四");
Thread redPack3 = new Thread(redPack);
redPack3.setName("王五");
Thread redPack4 = new Thread(redPack);
redPack4.setName("赵六");
Thread redPack5 = new Thread(redPack);
redPack5.setName("孙七");
redPack1.start();
redPack2.start();
redPack3.start();
redPack4.start();
redPack5.start();
}
}
线程的状态；
被创建：start()
运行；具备执行资格，同时具备执行权
冻结： sleep(time) , wait () -------------notiyf()唤醒， 线程释放了执行权，同时释放执行资格。
临时阻塞状态；线程具备cpu的执行资格，没有cpu的执行权。
消亡；stop ();
创建线程的第二种方式
步骤；
1.定义类实现Runnable接口
2.覆盖接口中的run方法（用于封装线程要运行的代码）
3.通过Thread 类创建线程对象
4.将实现了Runnable接口的子类对象作为实际参数传递给Threadl类中的构造函数。为什么要传递呢？因为让线程对象明确运行的run方法所属对象。
5.调用Thread对象的start方法，开启线程，并运行Runnable接口子类中的run方法。
多线程的安全问题的原因；
通过图解，发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进行，并操作了这个数据。导致到了错误数据的产生。
涉及到两个因素：
1.多个线程在操作共享数据。
2.有多条语句对共享数据进行运算。
解决安全问题的原理：
只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。
如何进行多句操作共享数据代码的封装呢？
java中提供了一个解决方式：就是同步代码块。
synchronized（对象){ //任意对象，这个对象就是锁
需要被同步的代码。
}
同步函数：
其实就是将同步关键字定义在同步函数上。让函数具备同步性。
同步函数是用的哪个锁呢？
通过验证，函数都有自己所属的this锁。
对于静态函数：该类的字节码文件对象，类名.class
同步死锁：通常只要将同步进行嵌套，就可以看到现象，同步函数中有同步代码块，同步代码块中还有同步函数。
线程间通信：
思路：多个线程操作同一资源，操作动作却不一样。
1.将资源封装成对象
2.将线程执行的任务（任务就是run方法），也封装成对象。
等待唤醒机制（线程间的通信）
wait :将同步中的线程处于冻结状态，释放了执行权，释放了资格。同步将线程对象存储到线程池中。
notify: 唤醒线程池中某一个等待线程。
notifyAll:唤醒的是线程池中所有的线程。
注意：
1.这些方法都需要定义在同步中。
2。因为要知道这些方法必须标示所属的锁。A锁上的线程被wait了，那这个线程就相当于处于A锁的线程池中，只能等A锁的notify唤醒。
3.这三个方法都定义在Object类中，为什么操作线程的方法定义在Object类中？因为这三个方法都需要定义同步内，并标示所属的同步锁，既然被锁调用了，那锁又可以是任意对象，那么能被任意对象调用的方法一定定义在Object类中。
wait 和sleep区别，分析这两个方法，从执行权和锁上来分析：
wait：可以指定时间，也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。
sleep:必须指定时间，时间到自动从冻结状态转成运行状态（临时阻塞状态）。
wait: 线程会释放执行权，而且线程会释放锁。
sleep:线程会释放执行权，但不是不释放锁。
线程的停止：
第一种方式：线程内都会定义循环，定义循环结束标志即可。
第二种方式： 如果线程处于冻结状态，是不可能读到标记的，这时就需要通过Thread类中的interrupt方法，将其冻结状态强制清除。让线程恢复具备执行资格的状态，让线程可以读到标记，并结束。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
