线程：
单核的cpu在一个时间片中只能执行一个应用程序
各个程序其实在做cpu的资源真多战而已 cpu做了快速的切换动作
疑问 ：线程负责了代码 的执行，我们之前没有学过线程，为什么代码可以执行呢？
运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码。
一个java应用程序至少有几个线程？
至少有两个线程， 一个是主线程负责main方法代码的执行，一个是垃圾回收器线程,负责了回收垃圾。
面试题
1）线程和进程有什么区别？
一个进程是一个独立(self contained)的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每个线程都拥有单独的栈内存用来存储本地数据。
2）如何在Java中实现线程？
创建线程有两种方式：
一、继承 Thread 类，扩展线程。
二、实现 Runnable 接口。
3）Thread 类中的 start() 和 run() 方法有什么区别？
调用 start() 方法才会启动新线程；如果直接调用 Thread 的 run() 方法，它的行为就会和普通的方法一样；为了在新的线程中执行我们的代码，必须使用 Thread.start() 方法。
多线程的好处：
1. 解决了一个进程能同时执行多个任务的问题。
2. 提高了资源的利用率。
多线程 的弊端：
1. 增加cpu的负担。
2. 降低了一个进程中线程的执行概率。
3. 引发了线程安全 问题。
4. 出现了死锁现象。
如何创建多线程：
创建线程的方式：
方式一：
1. 自定义一个类继承Thread类。
2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法中
疑问： 重写run方法的目的是什么？
每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码,
自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码。
3. 创建Thread的子类对象，并且调用start方法开启线程。
注意： 一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，
直接调用run方法就相当调用了一个普通的方法而已 并没有开启新的线程。
/*
需求： 模拟QQ视频与聊天同时在执行。
*/
class TalkThread extends Thread{
@Override
public void run() {
while(true){
System.out.println("hi，你好！开视频呗...");
}
}
}
class VideoThread extends Thread{
@Override
public void run() {
while(true){
System.out.println("视频视频....");
}
}
}
public class Demo2 {
public static void main(String[] args) {
TalkThread talkThread = new TalkThread();
talkThread.start();
VideoThread videoThread = new VideoThread();
videoThread.start();
}
}还可以使用 匿名内部类创建多线程：
public class Demo4_Thread {
/**
* @param args
*/
public static void main(String[] args) {
new Thread() { //1,继承Thread类
public void run() { //2,重写run方法
for(int i = 0; i < 1000; i++) { //3,将要执行的代码写在run方法中
System.out.println("aaaaaaaaaaaaaa");
}
}
}.start(); //4,开启线程
new Thread(new Runnable() { //1,将Runnable的子类对象传递给Thread的构造方法
public void run() { //2,重写run方法
for(int i = 0; i < 1000; i++) { //3,将要执行的代码写在run方法中
System.out.println("bb");
}
}
}).start(); //4,开启线程
}
}线程常用的方法：
Thread(String name) 初始化线程的名字
setName(String name) 设置线程对象名
getName() 返回线程的名字
重要 sleep() 线程睡眠指定的毫秒数。 静态的方法， 哪个线程执行了sleep方法代码那么就是哪个线程睡眠。
重要 currentThread() 返回当前的线程对象，该方法是一个静态的方法， 注意： 那个线程执行了currentThread()代码就返回那个线程 的对象。
一般是Thread.currentThread()取得当前的线程
getPriority() 返回当前线程对象的优先级 默认线程的优先级是5
s**etPriority(int newPriority)** 设置线程的优先级 虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。
*/
多线程加锁：
这里只介绍synchronized 还有其他锁 可以参考这个博主的
https://juejin.im/post/5a43ad786fb9a0450909cb5f
package cn.itcast.thread;
/*
需求： 模拟3个窗口同时在售50张 票 。
问题1 ：为什么50张票被卖出了150次？
出现 的原因： 因为num是非静态的，非静态的成员变量数据是在每个对象中都会维护一份数据的,三个线程对象就会有三份。
解决方案：把num票数共享出来给三个线程对象使用。使用static修饰。
问题2： 出现了线程安全问题 ?
线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。
java线程同步机制的方式：
方式一：同步代码块
同步代码块的格式：
synchronized(锁对象){
需要被同步的代码...
}
同步代码块要注意事项：
1. 任意的一个对象都可以做为锁对象。
2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。
需求： 一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取一千块，要求不准出现线程安全问题。
方式二：同步函数
出现线程安全问题的根本原因：
1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
2. 有多个语句操作了共享资源。
实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类
提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。
在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实际在就是在操作系统中启动了一个进程。
*/
class SaleTicket extends Thread{
static int num = 50;//票数 非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。
static Object o = new Object();
public SaleTicket(String name) {
super(name);
}
@Override
public void run() {
while(true){
//同步代码块
synchronized ("锁") {
if(num>0){
System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
num--;
}else{
System.out.println("售罄了..");
break;
}
}
}
}
}
public class Demo4 {
public static void main(String[] args) {
//创建三个线程对象，模拟三个窗口
SaleTicket thread1 = new SaleTicket("窗口1");
SaleTicket thread2 = new SaleTicket("窗口2");
SaleTicket thread3 = new SaleTicket("窗口3");
//开启线程售票
thread1.start();
thread2.start();
thread3.start();
}
}
线程的创建还有一个方法除了 继承线程 然后代码放入run之外
还可以继承Runable
class zz implements Runnable{
@Override
public void run() {
for (int i = 0; i <10; i++) {
System.out.println("nei");
}
}
}
zz qq=new zz();
Thread aa=new Thread(qq);
aa.start();
锁的话也可以有两种 一种是使用同步代码块
格式 在run里面 synchronized（锁对象）{需要同步的代码}
同步函数 使用synchronized来修饰一个函数
同步函数要注意的事项 ：
1. 如果是一个非静态的同步函数的锁 对象是this对象，如果是静态的同步函数的锁 对象是当前函数所属的类的字节码文件（class对象）。
2. 同步函数的锁对象是固定的，不能由你来指定 的。
推荐使用： 同步代码块。
原因：
1. 同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象是固定 的，不能由我们来指定。
2. 同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数 的所有代码都被同步了。
//静态的函数---->函数所属 的类的字节码文件对象--->BankThread.class 唯一的。
public static synchronized void getMoney(){
}
当class被加载倒内存的时候 会创建一个class对象 把内容都存到这个对象里面去 唯一
举个例子 用继承接口还有 同步函数来实现多线程
package day13;
class zz implements Runnable{
@Override
public void run() {
zz();
}
public synchronized void zz() {
for (int i = 0; i <10; i++) {
System.out.println("nei"+Thread.currentThread().getName());
}
}
}
public class new1 {
public static void main(String[] args) throws InterruptedException {
zz qq1=new zz();
zz qq2=new zz();
Thread aa=new Thread(qq1);
Thread bb=new Thread(qq2);
aa.start();
bb.start();
}
}
方式二：
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方法作为了线程的任务代码去执行了。
推荐使用： 第二种。 实现Runable接口的。
原因： 因为java单继承 ,多实现的。
/*
Thread类 的run方法
* @Override
public void run() {
if (target != null) {
target.run(); //就相当于Runnable实现类的对象的run方法作为了Thread对象的任务代码了。
}
}
*/
Thread.currentThread()获取当前正在执行的线程
System.out.println(Thread.currentThread().getName() + “…bb”);
礼让线程：
class MyThread extends Thread {
public void run() {
for(int i = 1; i <= 1000; i++) {
if(i % 10 == 0) {
Thread.yield(); //让出CPU
}
System.out.println(getName() + "..." + i);
}
}
}死锁问题； 相当于 一个人拿空调板 一个人拿电池 只有同时拿到时才可以进行下一步
举例：
package cn.itcast.thread;
/*
java中同步机制解决了线程安全问题，但是也同时引发死锁现象。
死锁现象：
死锁现象出现 的根本原因：
1. 存在两个或者两个以上的线程。
2. 存在两个或者两个以上的共享资源。
死锁现象的解决方案： 没有方案。只能尽量避免发生而已。
*/
class DeadLock extends Thread{
public DeadLock(String name){
super(name);
}
public void run() {
if("张三".equals(Thread.currentThread().getName())){
synchronized ("遥控器") {
System.out.println("张三拿到了遥控器，准备 去拿电池!!");
synchronized ("电池") {
System.out.println("张三拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
}
}
}else if("狗娃".equals(Thread.currentThread().getName())){
synchronized ("电池") {
System.out.println("狗娃拿到了电池，准备去拿遥控器!!");
synchronized ("遥控器") {
System.out.println("狗娃拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
}
}
}
}
}
public class Demo2 {
public static void main(String[] args) {
DeadLock thread1 = new DeadLock("张三");
DeadLock thread2 = new DeadLock("狗娃");
//开启线程
thread1.start();
thread2.start();
}
}
如何避免死锁 举个例子：
public void run() {
// TODO Auto-generated method stub
synchronized("zzz") {
synchronized("空调版") {
System.out.println(name+"拿到空调版");
synchronized("xx") {
System.out.println(name+"我拿到xx");
}
}
}
}
}
避免死锁就是保证这两个东西满足的前提是必须先满足其他一种情况
多线程总结 用接口Runnable来实现多线程 因为这样还可以继承其他类
用同步代码块来实现锁 尽量避免死锁
当前线程用Thread.currentThread()来表示
注意
public void run() {
/*System.out.println("this："+ this);
System.out.println("当前线程："+ Thread.currentThread());*/
for(int i = 0 ; i < 100 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}如果是Runnable来实现的话
this指的是这个接口实现类 而 Thread.currentThread指的是Thread那个类
还是贴一下 lock锁的代码吧 回顾的时候可以一眼知道
package com.heima.thread2;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Demo3_ReentrantLock {
/**
* @param args
*/
public static void main(String[] args) {
final Printer3 p = new Printer3();
new Thread() {
public void run() {
while(true) {
try {
p.print1();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread() {
public void run() {
while(true) {
try {
p.print2();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
new Thread() {
public void run() {
while(true) {
try {
p.print3();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
class Printer3 {
private ReentrantLock r = new ReentrantLock();
private Condition c1 = r.newCondition();
private Condition c2 = r.newCondition();
private Condition c3 = r.newCondition();
private int flag = 1;
public void print1() throws InterruptedException {
r.lock(); //获取锁
if(flag != 1) {
c1.await();
}
System.out.print("我");
System.out.print("是");
System.out.print("线程");
System.out.print("1");
System.out.print("\r\n");
flag = 2;
//this.notify(); //随机唤醒单个等待的线程
c2.signal();
r.unlock(); //释放锁
}
public void print2() throws InterruptedException {
r.lock();
if(flag != 2) {
c2.await();
}
System.out.print("我");
System.out.print("是");
System.out.print("线程");
System.out.print("2");
System.out.print("\r\n");
flag = 3;
//this.notify();
c3.signal();
r.unlock();
}
public void print3() throws InterruptedException {
r.lock();
if(flag != 3) {
c3.await();
}
System.out.print("我");
System.out.print("是");
System.out.print("线程");
System.out.print("3");
System.out.print("\r\n");
flag = 1;
c1.signal();
r.unlock();
}
}
回过头来又来看一遍ReentrantLock锁：
理解更多了点：
第一：r.lock();和r.unlock();
还是拿上面这个栗子来说 一个类里有三个方法 三个线程分别调用三个方法，都是抢占式的 那会不会当一个线程在执行的时候 另一个线程会抢断这个线程呢？
答案：不会的
因为这个这个方法加了锁lock
我原来以为多个线程调用同一段代码的时候这个锁才有用 后来知道了 范围还可以更广
因为 它是用代码中 同一个 r （ReentrantLock锁）来锁定这段代码的 注意是同一个
虽然r锁定的代码不一样 但是 他们都是由一个锁锁住的 一个锁只能锁一个
所以 当线程A执行的时候 是不会被线程B抢断的
第二：c1.await(); 意思就是睡眠 睡眠什么呢？
我理解的 睡眠这个线程的 当前位置 await()下面代码不会被执行 同时释放锁 如果被唤醒了 还是从之前被锁定的位置开始
————————————————————————————————————————————————————
线程通信：
package cn.itcast.thread;
/*
线程通讯： 一个线程完成了自己的任务时，要通知另外一个线程去完成另外一个任务.
生产者与消费者
wait(): 等待 如果线程执行了wait方法，那么该线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify方法才能唤醒。
notify()： 唤醒 唤醒线程池等待线程其中的一个。
notifyAll() : 唤醒线程池所有等待 线程。
wait与notify方法要注意的事项：
1. wait方法与notify方法是属于Object对象 的。
2. wait方法与notify方法必须要在同步代码块或者是同步函数中才能 使用。
3. wait方法与notify方法必需要由锁对象调用。
如果不加锁 会出现了线程安全问题。 价格错乱了…
*/
//产品类
class Product{
String name; //名字
double price; //价格
boolean flag = false; //产品是否生产完毕的标识，默认情况是没有生产完成。
}
//生产者
class Producer extends Thread{
Product p ; //产品
public Producer(Product p) {
this.p = p ;
}
@Override
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) {
e.printStackTrace();
}
}
}
}
}
}
//消费者
class Customer extends Thread{
Product p;
public Customer(Product p) {
this.p = p;
}
@Override
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 Demo5 {
public static void main(String[] args) {
Product p = new Product(); //产品
//创建生产对象
Producer producer = new Producer(p);
//创建消费者
Customer customer = new Customer(p);
//调用start方法开启线程
producer.start();
customer.start();
}
}
注意 锁是synchronized 等待是wait 唤醒是notify 对象得是锁的那个对象
wait：告诉当前线程放弃执行权，并放弃监视器（锁）并进入阻塞状态，直到其他线程持有获得执行权，并持有了相同的监视器（锁）并调用notify为止。
notify：唤醒持有同一个监视器（锁）中调用wait的第一个线程，例如，餐馆有空位置后，等候就餐最久的顾客最先入座。注意：被唤醒的线程是进入了可运行状态。等待cpu执行权。
notifyAll：唤醒持有同一监视器中调用wait的所有的线程。
如何解决生产者和消费者的问题？
可以通过设置一个标记，表示数据的（存储空间的状态）例如，当消费者读取了（消费了一次）一次数据之后可以将标记改为false，当生产者生产了一个数据，将标记改为true。
，也就是只有标记为true的时候，消费者才能取走数据，标记为false时候生产者才生产数据。
线程间通信其实就是多个线程在操作同一个资源，但操作动作不同，wait，notify（），notifyAll()都使用在同步中，因为要对持有监视器（锁）的线程操作，所以要使用在同步中，因为只有同步才具有锁。
为什么这些方法定义在Object类中
因为这些方法在操作线程时，都必须要标识他们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被统一锁上notify唤醒，不可以对不同锁中的线程进行唤醒，就是等待和唤醒必须是同一个锁。而锁由于可以使任意对象，所以可以被任意对象调用的方法定义在Object类中
wait() 和 sleep()有什么区别？
wait():释放资源，释放锁。是Object的方法
sleep():释放资源，不释放锁。是Thread的方法
定义了notify为什么还要定义notifyAll，因为只用notify容易出现只唤醒本方线程情况，导致程序中的所有线程都在等待。
线程的停止：
1. 停止一个线程 我们一般都会通过一个变量去控制的。
2. 如果需要停止一个处于等待状态下的线程，那么我们需要通过变量配合notify方法或者interrupt()来使用。notify需要锁对象 interrupt()不需要而且可以指定线程但是会抛出异常
调用线程对象的interrupt()时，sleep的线程会抛出InterruptedException异常，从而中断循环，终止线程。
但是如果是IO如输入这些阻塞，中断的方法又不起作用了，还有就是对于没有阻塞的线程，调用interrupt()是达不到终止线程的效果的。
对于IO阻塞，可以关闭IO通道
interrupt()的话会在中断位置抛出异常 抛出异常是为了线程从阻塞状态醒过来，并在结束线程前让程序员有足够的时间来处理中断请求。
Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。
因此，如果线程被上述几种方法阻塞，正确的停止线程方式是设置共享变量，并调用interrupt()（注意变量应该先设置）。
如果线程没有被阻塞，这时调用interrupt()将不起作用；否则，线程就将得到异常（该线程必须事先预备好处理此状况），
接着逃离阻塞状态。
A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
如：
public synchronized void run() {}那么锁对象就是这个对象
public synchronized static void xx(){}这个时候锁对象是这个class文件
举个例子：
package day13;
class xx implements Runnable{
public synchronized void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName());
}
}
}
public class new1 {
public static void main(String[] args) throws InterruptedException {
xx zz=new xx();
for (int i = 0; i < 4; i++) {
Thread aa=new Thread(zz);
aa.setName("name"+i);
aa.start();
}
}
}锁是zz这个对象 所以不会发生混乱
wait要放在synchronized就是锁的里面 wait要对象才行 一般配合着都是wait锁
wait是把当前线程放入锁线程池中
notify是唤醒锁中的任意一个线程
一、sleep和wait的主要区别：
1、这两个方法来自不同的类分别是Thread和Object
2、最主要是sleep方法没有释放锁，而 wait 方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）
4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
5、sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.
线程中断
/*
线程的停止：
1. 停止一个线程 我们一般都会通过一个变量去控制的。
2. 如果需要停止一个处于等待状态下的线程，那么我们需要通过变量配合notify方法或者interrupt()来使用。
*/
package day13;
class zx implements Runnable{
boolean flag=true;
int i=0;
public synchronized void run() {
while(flag) {
/*try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}*/
System.out.println("内"+i);
}
}
}
public class new1 {
public static void main(String[] args) throws InterruptedException {
zx xx=new zx();
Thread aa=new Thread(xx);
aa.start();
for (int i = 0; i < 100; i++) {
System.out.println("main"+i);
if(i==30) {
xx.flag=false; 设置了变量控制
aa.interrupt();//把线程的等待状态强制清除，被清除状态的线程会接收到一个
InterruptedException。
}
}
}
}但是取消了对象中try的注释 那么系统就无法停止
因为线程是wait状态 要取消有两种方法
一种是
/*synchronized (xx) {
xx.notify();
}*/
这样子把该对象线程池中线程唤醒出来
第二种是：
xx.flag = false;
aa.interrupt(); //把线程的等待状态强制清除，被清除状态的线程会接收到一个InterruptedException。
可以指定唤醒哪个线程 而notify不行
注意：使用了 wait后就释放了锁其他线程可以进来 放入对应的锁线程池中等待唤醒或者强制打断
interrupt并不是直接打断线程 而是告诉线程你该被取消了 给线程加上了标识符true
如果这个时候有wait或者sleep等阻塞的时候那么就会强制打断线程（取消wait状态） 标识符再改为false
如果没有wait等阻塞那么只是给线程加上true而已 不会打断线程
但是注意： i0之类的阻塞不能用interrupt
而且一旦中断就会抛出异常
记住 wait是object 一般都是这个同步锁
interrupt是指定清除哪个线程的等待状态
而notify是随机一个
守护线程 ：
后台线程：就是隐藏起来一直在默默运行的线程，直到进程结束。
实现：
setDaemon(boolean on)
特点：
当所有的非后台线程结束时，程序也就终止了同时还会杀死进程中的所有后台线程，也就是说，只要有非后台线程还在运行，程序就不会终止，执行main方法的主线程就是一个非后台线程。
必须在启动线程之前（调用start方法之前）调用setDaemon（true）方法，才可以把该线程设置为后台线程。
一旦main（）执行完毕，那么程序就会终止，JVM也就退出了。
可以使用isDaemon() 测试该线程是否为后台线程（守护线程）。
package cn.itcast.thread;
/*
守护线程（后台线程）:在一个进程中如果只剩下 了守护线程，那么守护线程也会死亡。
需求： 模拟QQ下载更新包。
一个线程默认都不是守护线程。
*/
public class Demo7 extends Thread {
public Demo7(String name){
super(name);
}
@Override
public void run() {
for(int i = 1 ; i<=100 ; i++){
System.out.println("更新包目前下载"+i+"%");
if(i==100){
System.out.println("更新包下载完毕,准备安装..");
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Demo7 d = new Demo7("后台线程");
d.setDaemon(true); //setDaemon() 设置线程是否为守护线程，true为守护线程， false为非守护线程。
// System.out.println("是守护线程吗？"+ d.isDaemon()); //判断线程是否为守护线程。
d.start();
for(int i = 1 ; i<=100 ; i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
Timer：
线程安排在后台执行的任务 可执行一次或者多次重复
就比如手机闹铃 可定期重复响铃
public static void main(String[] args) throws InterruptedException {
Timer t = new Timer();
//在指定时间安排指定任务
//第一个参数,是安排的任务,第二个参数是执行的时间,第三个参数是过多长时间再重复执行
t.schedule(new MyTimerTask(), new Date(188, 6, 1, 14, 22, 50),3000);
while(true) {
Thread.sleep(1000);
System.out.println(new Date());
}
}
}
class MyTimerTask extends TimerTask {
@Override
public void run() {
System.out.println("起床背英语单词");
}总结：
TimerTask是继承runnable
写个类继承TimerTask即可
简单线程池创建：
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(2);//创建线程池
pool.submit(new MyRunnable()); //将线程放进池子里并执行
pool.submit(new MyRunnable());
pool.shutdown(); //关闭线程池
}多线程还有一种创建方法 ：了解就行 可以有返回值 可以抛出异常
class MyCallable implements Callable<Integer> {
private int num;
public MyCallable(int num) {
this.num = num;
}
@Override
public Integer call() throws Exception {
int sum = 0;
for(int i = 1; i <= num; i++) {
sum += i;
}
return sum;
}
}
public class One {
public static void main(String args[]) throws InterruptedException, ExecutionException {
ExecutorService pool = Executors.newFixedThreadPool(2);//创建线程池
Future<Integer> f1 = pool.submit(new MyCallable(100)); //将线程放进池子里并执行
Future<Integer> f2 = pool.submit(new MyCallable(50));
System.out.println(f1.get());
System.out.println(f2.get());
}
}join：
Thread的join方法
当A线程执行到了B线程Join方法时A就会等待，等B线程都执行完A才会执行，Join可以用来临时加入线程执行
/*
join方法。 加入
*/
//老妈
class Mon extends Thread{
public void run() {
System.out.println("妈妈洗菜");
System.out.println("妈妈切菜");
System.out.println("妈妈准备炒菜，发现没有酱油了..");
//叫儿子去打酱油
Son s= new Son();
s.start();
try {
s.join(); //加入。 一个线程如果执行join语句，那么就有新的线程加入，
执行该语句的线程必须要让步给新加入的线程先完成任务，然后才能继续执行。
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("妈妈继续炒菜");
System.out.println("全家一起吃饭..");
}
}
class Son extends Thread{
@Override
public void run() {
System.out.println("儿子下楼..");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("儿子一直往前走");
System.out.println("儿子打完酱油了");
System.out.println("上楼，把酱油给老妈");
}
}
public class Demo8 {
public static void main(String[] args) {
Mon m = new Mon();
m.start();
}
}
线程组：
class MyRunnable implements Runnable {
@Override
public void run() {
for(int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName() + "...." + i);
}
}
}
public static void main(String[] args) {
//demo1();
ThreadGroup tg = new ThreadGroup("我是一个新的线程组"); //创建新的线程组
MyRunnable mr = new MyRunnable(); //创建Runnable的子类对象
Thread t1 = new Thread(tg, mr, "张三"); //将线程t1放在组中
Thread t2 = new Thread(tg, mr, "李四"); //将线程t2放在组中
System.out.println(t1.getThreadGroup().getName()); //获取组名
System.out.println(t2.getThreadGroup().getName());
tg.setDaemon(true);
}1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。
2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）
3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；
4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；
有朋友可能会有疑问：为何这三个不是Thread类声明中的方法，而是Object类中声明的方法（当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法）？其实这个问题很简单，由于每个对象都拥有monitor（即锁），所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作了。而不是用当前线程来操作，因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。
上面已经提到，如果调用某个对象的wait()方法，当前线程必须拥有这个对象的monitor（即锁），因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。
调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，等待后续再次获得此对象的锁（Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它并不释放对象锁）；
notify()方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。
同样地，调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。
nofityAll()方法能够唤醒所有正在等待该对象的monitor的线程，这一点与notify()方法是不同的。
这里要注意一点：notify()和notifyAll()方法只是唤醒等待该对象的monitor的线程，并不决定哪个线程能够获取到monitor。
举个简单的例子：假如有三个线程Thread1、Thread2和Thread3都在等待对象objectA的monitor，此时Thread4拥有对象objectA的monitor，当在Thread4中调用objectA.notify()方法之后，Thread1、Thread2和Thread3只有一个能被唤醒。注意，被唤醒不等于立刻就获取了objectA的monitor。假若在Thread4中调用objectA.notifyAll()方法，则Thread1、Thread2和Thread3三个线程都会被唤醒，至于哪个线程接下来能够获取到objectA的monitor就具体依赖于操作系统的调度了。
上面尤其要注意一点，一个线程被唤醒不代表立即获取了对象的monitor，只有等调用完notify()或者notifyAll()并退出synchronized块，释放对象锁后，其余线程才可获得锁执行。
package fuxi;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import javax.swing.JButton;
public class One {
public static Object object = new Object();
public static void main(String[] args) {
Thread1 thread1 = new Thread1();
Thread2 thread2 = new Thread2();
thread1.start();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.start();
}
static class Thread1 extends Thread{
@Override
public void run() {
synchronized (object) {
try {
System.out.println("1");
object.wait();
} catch (InterruptedException e) {
}
System.out.println("3");
System.out.println("线程"+Thread.currentThread().getName()+"获取到了锁");
}
}
}
static class Thread2 extends Thread{
@Override
public void run() {
synchronized (object) {
System.out.println("2");
object.notify();
System.out.println("4");
System.out.println("线程"+Thread.currentThread().getName()+"调用了object.notify()");
}
System.out.println("线程"+Thread.currentThread().getName()+"释放了锁");
}
}
}
运行结果是：
1
2
4
线程Thread-1调用了object.notify()
3
线程Thread-1释放了锁
线程Thread-0获取到了锁得到的结论是 如果一个线程A wait必须在锁内 而且唤醒的话 线程B也要在锁内 而且是等这个锁内代码执行完之后才开始再次竞争 不一定被线程A抢到锁 可能还是B抢到锁 还有 如果A抢到锁了 那么就会继续上次的执行 这个就是线程抢占CPU 一样 被抢占的那个记录自己运行位置 抢回来后 继续那个位置执行
参考自：
http://www.cnblogs.com/dolphin0520/p/3920385.html
