标签：锁对象 构造 线程池 ble alt 通讯 style auto justify
正在运行的程序称之为一个进程，进程负责了这个程序的内存空间分配，代表了内存中的执行区域。
问题：windows号称是多任务的操作系统，那么windows是同时运行多个应用程序吗？
从宏观的角度：windows确实是在同时运行多个应用程序。
从微观的角度：cpu是做了一个快速的切换执行的动作，由于速度太快，所以我们感觉不到他在进行切换。
单核的cpu在一个时间片中，只能执行一个应用程序；其实各个应用程序是在做cpu的资源争夺战而已，cpu做了快速的切换。
就是在一个进程中负责一个执行路径。进程中有很多代码，线程负责执行进程中的代码。
就是在一个进程中多个执行路径同时执行。例如金山卫士中的垃圾清理，和木马查杀，同时运行，就是在一个进程中，有两个线程，同时在执行两个不同的代码。简单的说，就是在一个进程中有多个线程同时在执行不同的任务。进程中的代码是由线程来执行。
与其说是进程在做cpu的争夺战 ，还不如说是线程在做cpu的资源的争夺战。
疑问1：线程负责了代码的执行,我们之前没有学过线程，为什么代码可以执行呢？
因为，任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中的所有代码。
疑问2：一个java应用程序至少有几个线程？
一个java应用程序至少有两个线程，一个主线程负责main方法代码的执行，一个是垃圾回收器的线程，负责了回收垃圾。
1 自定义一个类继承Thread类
2.重写Thread类的run方法。
3.创建Thread的子类对象，并且调用start方法开启线程。
注意：一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，直接调用run方法就相当于调用了一个普通的方法而已，并没有开启线程。
4. 疑问：重写run方法的目的是什么？
因为，每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码，自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中的代码。
重写run方法的目的就是，为了把自定义线程的任务定义在run方法中。
线程的线程周期如下图：
1 构造方法
Thread(String name) 初始化线程的名字
2 常用方法
2.1 getName() 返回线程的名字
2.2 setName(String name) 设置线程对象名
2.3 sleep() 线程睡眠指定的毫秒数。
注意：Sleep（）方法是静态的方法，哪个线程执行了sleep方法代码，那么就是哪个线程睡眠。
2.4currentThread() 返回CPU正在执行的线程的对象
注意：currentThread（）方法是静态的方法，哪个线程执行了currentThread（）方法代码，那么就返回哪个方法的对象。
2.5getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
2.6setPriority(int newPriority) 设置线程的优先级 虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。
1.存在两个或者两个以上的线程对象，而且线程之间共享着一个资源。
2.有多个语句操作了共享资源。
方式一：同步代码块
同步代码块的格式：
Synchronized（锁对象）{
需要被同步的代码......
}
同步函数就是使用synchronized修饰一个函数，也就是说，把一个方法使用Synchronized修饰。
1.如果是一个非静态的同步函数的锁 对象是this对象，如果静态的同步函数的锁 对象是当前函数所属的类的字节码文件（class对象）。
2.同步函数的锁对象是固定的，不能有你来确定。
//静态的函数---->函数所属 的类的字节码文件对象--->BankThread.class 唯一的。
public static synchronized void getMoney (){
}
在JDK中，有一个class 类来描述字节码文件。
字节码文件是如何产生的？
1.任意的一个对象都可以作为锁对象，因为，凡是对象内部都维护了一个状态的，java的同步机制就是使用了对象中的状态作为了锁的标识。
State = 1 开
Stqate=0 关
这些状态是隐士维护的。
线程先进入到同步代码块时，首先先进入到“锁”，看看“锁”是否开启，若是没有人执行，“锁”默认是开启的，线程要执行“代码”，进入“锁”后，将“锁”的状态改变成关。只有当线程出了同步代码块后，就将“锁”打开。就是抢“锁”原理。
2.在同步代码块中调用了sleep方法并不是释放“锁”对象。
3.只有真正存在线程安全问题的时候，才会使用同步代码块，否则会点滴效率
4.多线程操作的锁对象，必须是唯一共享的，否则无效。
原因：
1. 同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的代码块是固定的，不能由我们来指定。
2. 同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数的所有代码都被同步了。
上述代码出现死锁的原因是因为：“张三”执行代码，执行到同步函数synchronized（“遥控器”），将“遥控器”对象“锁住”，与此同时，“狗娃”执行代码，执行到同步函数synchronized（“电池”），将“电池”对象“锁住。所以。。。。就会锁住啦，也有可能不锁。
1. 存在两个或者两个以上的线程。
2. 存在两个或者两个以上的共享资源。
没有解决的方案，只能尽量的避免发生而已。
方式一 ：
1. 自定义一个类继承Thread类。
2. 重写Thread类的run方法，把自定义线程的任务代码写在run方法上。
3. 创建Thread的子类对象，并且调用start方法启动一个线程。
注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码，如果直接调用
run方法，那么就 相当于调用了一个普通的方法而已。
方式二：
1. 自定义一个类实现Runnable接口。
2. 实现Runnable接口 的run方法，把自定义线程的任务定义在run方法上。
3. 创建Runnable实现类对象。
4. 创建Thread类 的对象，并且把Runnable实现类的对象作为实参传递。
5. 调用Thread对象 的start方法开启一个线程。
问题1： 请问Runnable实现类的对象是线程对象吗？
Runnable实现类的对象并 不是一个线程对象，只不过是实现了Runnable接口 的对象而已。
只有是Thread或者是Thread的子类才是线程 对象。
问题2： 为什么要把Runnable实现类的对象作为实参传递给Thread对象呢？作用是什么？
作用就是把Runnable实现类的对象的run方法作为了线程的任务代码去执行了。
Thread类 的run方法
* @Override
public void run() {
if (target != null) {
target.run(); //就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了。
}
}
就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了
推荐使用： 第二种。 实现Runable接口的。
原因： 因为java单继承 ,多实现的。
线程通讯： 一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务.
售票问题：
如上述代码,为什么num没有使用static代码，售票却没有出现问题呢，其原因是因为，在创建SaleTicket对象的时候，只创建了一次，所以，在内存中只维护一个num。
如果线程执行了wait方法，那么该线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify方法才能唤醒。
Wait() :如果一个线程执行了wait方法，那么该线程就会进去一个以锁对象为标识符的线程池中等待。
Notify（）:如果一个线程执行了notify方法，那么就唤醒以锁对象为标识符的线程中等待线程其中一个。
2.1 notify(): 唤醒线程池等待线程其中的一个。
2.2 notifyAll() : 唤醒线程池所有等待 线程。
2.3wait与notify方法要注意的事项：
1. wait方法与notify方法是属于Object对象 的。
2. wait方法与notify方法必须要在同步代码块或者是同步函数中才能 使用。
3. wait方法与notify方法必需要由锁对象调用。
首先，假设生产者拿到了cpu的执行权，对标志位flag进行判断，flag是false状态，生产者进入其中，生产者生产苹果，6.5元，接着生产者继续拿到了cpu的执行权，代码向下执行，将标志位flag更改成true，i++，执行p.notify（）方法，由于此时p线程池中还没有在等待的线程，所以，代码继续执行。生产者回到最初的起点，对标志位进行判断，判断结果不符合，生产者执行wait（）进行等待，在等待的过程中，jvm就会以“锁”对象为标识建立线程池，此时生产者线程进入线程池中进行等待。
由于生产者线程执行了wait方法，并且进入了线程池进行等待，此时，“锁”对象被生产者释放；此时消费者拿到了cpu的执行权，消费者首先对标志位flag进行判断，判定后进行消费，消费后将标志位更改为false，而后执行p.notify(),唤醒“锁”对象为标识符的线程中等待线程中的一个线程。接着消费者继续执行，首先进行标志位判定，发现判定失败，执行wait()方法，此时消费者进入线程池中进行等待，失去了cpu的执行权。此时生产者获得cpu的执行权，周而复始。如上所述。很可爱。
Q1：wait和notify方法为什么必须要在同步代码块中使用？
因为如果不存在着同步代码块或者同步函数，就没有“锁”的存在，而wait和notify方法，一定要由“锁”来进行调用，所以wait 和notify方法一定要在同步代码块或者同步函数中使用。
Q2：wait和notify方法为什么必须要用锁对象调用？
因为wait()和notify()方法要以“锁”对象为标识符建立线程池的，所有wait和notify方法必须要用“锁”对象调用，且调用的时候，所使用的“锁”必须是同一把锁。因为，不同的“锁”，建立的线程池并不相同。
Q3：如果wait和notify方法一旦不用“锁”来进行调用那么一定会报错。
class Product{
String name;
double price;
boolean flag =false;
}
class Producer extends Thread{
Product p;
public Producer(Product p){
this.p=p;
}
public void run(){
int i=0;
while(true){
synchronized(p){
if(p.flag==false){
if(i%2==0){
p.name = "苹果";
p.price=6.5;
}else{
p.name ="香蕉";
p.price =2.0;
}
System.out.println("生产者生产出了："+p.name+"价格是："+ p.price);
p.flag =true;
i++;
p.notifyAll();
}else{
try {
p.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
}
class Custormer extends Thread{
Product p;
public Custormer (Product p){
this.p=p;
}
public void run(){
while (true){
synchronized (p){
if(p.flag==true){
System.out.println("消费者消费了"+p.name+"价格："+p.price);
p.flag =false;
p.notifyAll();
}else{
try {
p.wait(); //消费者也等待了...
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class Demo6 {
public static void main(String[] args){
Product p = new Product();
Producer pro =new Producer(p);
Custormer cus = new Custormer(p);
pro.start();
cus.start();
}
}
1.停止一个线程一般都会通过一个变量去控制。
2.如果需要停止一个处于等待状态下的线程，那么我们需要通过变量配合notify方法或者interrupt()来使用。
守护线程（后台线程）：在一个进程中如果只剩下了守护线程，那么守护线程也会死亡。
需求：模拟QQ下载更新包。
一个线程默认都不是守护线程。
John（）加入，一个线程如果执行了john语句，那么就有新的线程加入，执行该语句的线程必须要让步给新加入的线程完成任务，然后才能继续执行。
标签：锁对象 构造 线程池 ble alt 通讯 style auto justify
原文地址：http://www.cnblogs.com/xiangnianchulian/p/7569920.html
