线程（杂）-白红宇

线程：

单核的cpu在一个时间片中只能执行一个应用程序

各个程序其实在做cpu的资源真多战而已 cpu做了快速的切换动作

疑问：线程负责了代码的执行，我们之前没有学过线程，为什么代码可以执行呢？

运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码。

一个java应用程序至少有几个线程？

至少有两个线程，一个是主线程负责main方法代码的执行，一个是垃圾回收器线程,负责了回收垃圾。

多线程的好处：

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{

@Overridepublic void run() {    while(true){        System.out.println("hi，你好！开视频呗...");    }}

}

class VideoThread extends Thread{

@Overridepublic 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();}

}

线程常用的方法：

Thread(String name) 初始化线程的名字

setName(String name) 设置线程对象名

getName() 返回线程的名字

重要 sleep()                 线程睡眠指定的毫秒数。 静态的方法， 那个线程执行了sleep方法代码那么就是那个线程睡眠。重要 currentThread()      返回当前的线程对象，该方法是一个静态的方法， 注意： 那个线程执行了currentThread()代码就返回那个线程 的对象。 一般是Thread.currentThread()取得当前的线程 getPriority()             返回当前线程对象的优先级   默认线程的优先级是5 setPriority(int newPriority) 设置线程的优先级    虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的实现（最大的优先级是10 ，最小的1 ， 默认是5）。

多线程加锁：

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);}@Overridepublic 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{

@Overridepublic void run() {    // TODO Auto-generated method stub    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{

@Overridepublic void run() {    // TODO Auto-generated method stub    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对象的任务代码了。        }    }*/

死锁问题；相当于一个人拿空调板一个人拿电池只有同时拿到时才可以进行下一步

举例：

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那个类

线程通信：

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 ;}@Overridepublic 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;}@Overridepublic 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 对象得是锁的那个对象

线程的停止：

1. 停止一个线程我们一般都会通过一个变量去控制的。

2. 如果需要停止一个处于等待状态下的线程，那么我们需要通过变量配合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(); //没有任何效果

//aa.interrupt();            }        }}

}

但是取消了对象中try的注释那么系统就无法停止

因为线程是wait状态要取消有两种方法

一种是

/*synchronized (xx) {

xx.notify();

}*/

这样子把该对象线程池中线程唤醒出来

第二种是：

xx.flag = false;

aa.interrupt(); //把线程的等待状态强制清除，被清除状态的线程会接收到一个InterruptedException。

注意：使用了 wait后就释放了锁其他线程可以进来放入对应的锁线程池中等待唤醒或者强制打断

interrupt并不是直接打断线程而是告诉线程你该被取消了给线程加上了标识符true

如果这个时候有wait或者sleep等阻塞的时候那么就会强制打断线程（取消wait状态）标识符再改为false

如果没有wait等阻塞那么只是给线程加上true而已不会打断线程

但是注意： i0之类的阻塞不能用interrupt

而且一旦中断就会抛出异常

记住 wait是object 一般都是这个同步锁

interrupt是指定清除哪个线程的等待状态

而notify是随机一个

守护线程：

package cn.itcast.thread;

守护线程（后台线程）:在一个进程中如果只剩下了守护线程，那么守护线程也会死亡。

需求：模拟QQ下载更新包。

一个线程默认都不是守护线程。

public class Demo7 extends Thread {

public Demo7(String name){    super(name);}@Overridepublic 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);     }}

}

join：

package cn.itcast.thread;

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{

@Overridepublic 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();}

}