黑马程序员----java基础--多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、进程、线程、多进程的概念

1、进程和线程

进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。

2、java虚拟机就是多线程程序

jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

3、多线程的好坏之处 

多线程的好处：解决了多部分代码同时运行的问题。
多线程的弊端：线程太多，会导致效率的降低。
其实，多个应用程序同时执行都是CPU在做着快速的切换完成的。这个切换是随机的。哪个线程抢到了cpu的执行权，哪个线程就执行。CPU的切换是需要花费时间的，从而导致了效率的降低。

创建线程的目的就是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行，而运行的指定代码就是这个执行路径的任务。

二、创建线程的方式

1、获取当前线程名称

Thread.currentThread().getName();

线程的名称是由：Thread-编号定义的。编号从0开始。

线程要运行的代码都统一存放在了run方法中。

2、创建线程的方式

(1)、第一种方式：继承Thread类，由子类复写run方法。

1. 定义一个类继承Thread类。
2. 覆盖Thread类中的run方法。
3. 直接创建Thread的子类对象创建线程。
4. 调用start方法开启线程并调用线程的任务run方法执行。

run方法就是封装自定义线程运行任务的函数，run方法中定义的就是线程要运行的任务代码。记住：把需要开启多线程的运行代码都写到run方法中。

代码演示：

//继承Thread类，复写run方法
class Demo extends Thread
{
    public void run(){//run方法内不能抛异常，只能try catch。因为该方法是复写Thread类中的run方法。Thread类中的run方法没有抛异常
        for (int x=0;x<70 ;x++ )
        {
            System.out.println(Thread.currentThread().getName()+"....."+x);
        }
    }
}
class ThreadDemo 
{
    public static void main(String[] args) //开启了两个线程：Demo和main。两个线程交替运行
    {
        new Demo().start();//创建子类对象，并开启线程，调用run方法
        for (int x=0;x<70 ;x++ )
        {
            System.out.println(Thread.currentThread().getName()+":::"+x);//mian函数的线程名称就是：main
        }
    }
}

  自定义线程名称的方法

class Demo extends Thread
{
    private String name;
    Demo(String name){
        super(name);
    }
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
}
class ThreadDemo
{
    publici static void main(Stirng[] args){
        new Demo("线程一").start();
        new Demo("线程二").start();
    }
}                   

(2)、创建线程的第二种方式：实现Runnable接口,复写run方法。

1.定义类实现Runnable接口

2.覆盖接口中的run方法（用于封装线程要运行的代码）

3.通过Thread类创建线程对象

4.将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。

为什么要传递呢？线程的任务都封装在Runnable接口子类对象的run方法中，所以要在线程对象创建时就必须明确要运行的任务。

5.调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

为什么要有Runnable接口的出现？

1.通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。

可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？

只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。

所以，通常创建线程都用第二种方式。因为实现Runnable接口可以避免单继承的局限性。

2.其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。

实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。

代码演示： 

//实现Runnable，复写run方法
class Demo implements Runnable
{
    public void run(){
        for (int x=0;x<60 ;x++ )
        {            
            System.out.println(Thread.currentThread().getName()+".."+x);
        }
    }
}
class ThreadDemo
{
    public static void main(String[] args) 
    {
        new Thread(new Demo()).start();
        for (int x=0;x<60 ; x++)
        {
            System.out.println(Thread.currentThread().getName()+":::::"+x);
        }
    }
}

 (3)、线程状态

被创建：start()

运行：具备了执行资格，同时也具备执行权

临时阻塞状态：线程具备cpu的执行资格，但是没有cpu的执行权

冻结：sleep(time)，wait()--notify()，失去执行资格和执行权。sleep方法时间到或者调用notify()方法时，获得执行资格，变为临时状态

消亡：stop()方法，或者run()方法结束

三、线程安全问题

1、多线程安全问题的原因

通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

涉及到两个因素：

1.多个线程在操作共享数据。

2.有多条语句对共享数据进行运算。

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

2、线程安全问题的解决方案

解决安全问题的原理：

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

解决同步的方式：
(1)、同步代码块的格式：
    synchronized(对象){// 任意对象都可以。这个对象就是锁。
           需要被同步的代码;
    } 
同步的好处：解决了线程的安全问题。
同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
同步的前提：必须有多个线程并使用同一个锁。

 需求：模拟4个线程同时卖100张票。

//加上同步代码块后
class Ticket implements Runnable
{
    private int ticket=100;
    private Object obj=new Object();
    public void run(){
        while (true)
        {
            synchronized(obj){//加上同步代码块后，obj对象相当于一把锁，一个线程进去后,其他线程无法进去，只有当这个线程执行完，跳出同步后，另一个才能进去
                if (ticket>0)//一个线程进同步有两个隐式操作，刚进同步后：上锁，跳出同步后：释放锁
                {
                    try{Thread.sleep(20);}catch(Exception e){}//让线程停止20毫秒，这时候出现了线程等于0、-1、-2的情况
                    System.out.println(Thread.currentThread().getName()+"..."+ticket--);//出现问题的原因是：线程停止了20毫秒后，继续运行的时候没有判断if的条件。
                }
            }
        }
        
    }    
}
class TicketDemo 
{
    public static void main(String[] args) 
    {
        Ticket t=new Ticket();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
        new Thread(t).start();
    }
}

 需求：储户，两个，每个都到银行存钱，每次存100，共存三次。

class Bank
{
    private Object obj=new Object();
    private int sum;
    public void add(int num){
        synchronized(obj){
            sum=sum+num;
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println("sum="+sum);
        }
    }
}
class Person implements Runnable
{
    private Bank b=new Bank();
    public void run(){
        for(int x=0;x<3;x++){
            b.add(100);
        }
    }
}
class BankDemo 
{
    public static void main(String[] args) 
    {
        Person p=new Person();
        new Thread(p).start();
        new Thread(p).start();
    }
}

 (2)、同步函数

同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。

上面的代码可以用同步函数代替同步代码块。

class Bank
{
    private int sum;
    public synchronized void add(int num){        
        sum=sum+num;
        try{Thread.sleep(10);}catch(Exception e){}
        System.out.println("sum="+sum);        
    }
}

同步函数用的是哪一个锁呢？函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。

同步函数和同步代码块的区别：
1. 同步函数的锁是固定的this。
2. 同步代码块的锁是任意的对象。
建议使用同步代码块。

关于同步函数用的是this锁，可以通过该程序进行验证。使用两个线程来买票。一个线程在同步代码块中。一个线程在同步函数中。都在执行卖票动作。

class Ticket implements Runnable
{
    private int ticket=100;
     boolean flag;
    public void run(){
        if(flag){
            while (true)
            {
                synchronized(this){
                    if(ticket>0){
                        try{Thread.sleep(10);}catch(Exception e){}
                        System.out.println(Thread.currentThread().getName()+"..obj."+ticket--);
                    }
                }                
            }            
        }
        else
            while(true)
                show();
    }
    public synchronized void show(){        
        if(ticket>0){
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"::this::"+ticket--);
        }
        
    }
}
class ThisLockDemo 
{
    public static void main(String[] args) 
    {
        Ticket t=new Ticket();
        new Thread(t).start();
        try{Thread.sleep(10);}catch(Exception e){}//让线程一先sleep一会，这时候主线程还获取执行权，继续向下执行
        t.flag=true;//标记为true，这时候会运行show方法中的代码
        new Thread(t).start();
    }
}

 上面的代码显示两个线程交替执行而且把100张票卖完了，而且没有出现0号和负数的票，说明两个线程是安全的，同时也说明了同步函数用的锁是this。

(3)、静态同步函数

当同步函数被static修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。

这个对象就是 类名.class。

还是用卖票的程序可以验证静态同步函数的锁是.class。

class Ticket implements Runnable
{
    private static int ticket=100;
    boolean flag;
    public void run(){
        if(flag){
            while (true)
            {
                synchronized(Ticket.class){
                    if(ticket>0){
                        try{Thread.sleep(10);}catch(Exception e){}
                        System.out.println(Thread.currentThread().getName()+"..obj."+ticket--);
                    }
                }                
            }            
        }
        else
            while(true)
                show();
    }
    public static synchronized void show(){        
        if(ticket>0){
            try{Thread.sleep(10);}catch(Exception e){}
            System.out.println(Thread.currentThread().getName()+"::this::"+ticket--);
        }
        
    }
}
class ThisLockDemo 
{
    public static void main(String[] args) 
    {
        Ticket t=new Ticket();
        new Thread(t).start();
        try{Thread.sleep(10);}catch(Exception e){}//让线程一先sleep一会，这时候主线程还获取执行权，继续向下执行
        t.flag=true;//标记为true，这时候会运行show方法中的代码
        new Thread(t).start();
    }
}

在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。

四、多线程下的单例设计模式

饿汉式不存在线程安全问题，因为操作的代码只有一句。

class Single 
{
    private Single(){}
    private static final Single s=new Single();
    public static Single getInstance(){
        return s;
    }
}

懒汉式存在安全问题，可以使用同步函数解决。若直接使用同步函数，则效率较低，因为每次都需要判断。可通过双重判断的方法解决效率问题。

class Single
{
    private Single(){}
    private static Single s=null;
    public static Single getInstance(){//如果在函数上加上synchronized就出现了每次都判断锁
        if(s==null){//双重判断是否为空可以解决低效问题。
            synchronized(Single.class){
                if(s==null){
                    s=new Single();            
                }
            }            
        }        
        return s;
    }
}

 五、死锁

所谓的死锁就是同步中嵌套同步，在开发过程中避免发生死锁现象。

演示：制造一个死锁程序。 

class DeadLock implements Runnable
{
    private boolean flag;
    DeadLock(boolean flag){
        this.flag=flag;
    }
    public void run(){    
        if(flag){
            while (true)
            {
                synchronized(MyLock.locka){//同步代码块中嵌套同步代码块
                    System.out.println("if....locka...");
                    synchronized(MyLock.lockb){
                        System.out.println("if....lockb...");
                    }
                }
            }                
        }
        else{
            while (true)
            {
                synchronized(MyLock.lockb){
                    System.out.println("else-----lockb--");
                    synchronized(MyLock.locka){
                        System.out.println("else-----locka---");
                    }
                }
            }                
        }
    }    
}
class MyLock
{
    public static MyLock locka=new MyLock();
    public static MyLocks lockb=new MyLock();
}
class DeadLockDemo 
{
    public static void main(String[] args) 
    {
        new Thread(new DeadLock(true)).start();
        new Thread(new DeadLock(false)).start();

    }
}

 六、线程间通信问题

线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。

1.将资源封装成对象。

2.将线程执行的任务(任务其实就是run方法。)也封装成对象。

等待/唤醒机制涉及的方法：
1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。
2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。
3. notifyAll()：唤醒线程池中的所有线程。

这些方法都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？
　　因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

wait和sleep区别？
1.wait可以指定时间也可以不指定。sleep必须指定时间。
2.在同步中时，对CPU的执行权和锁的处理不同。
wait：释放执行权，释放锁。
sleep：释放执行权，不释放锁。

(1)、一个生产者，一个消费者。即： 一个线程负责生产，一个线程负责消费

代码演示：

class Resource
{
    private String name;
    private String sex;
    private boolean flag;
    public synchronized void set(String name,String sex){
        if(flag)//如果为真，执行下面wait方法，线程处于等待状态，释放了执行权并且放弃了锁。
            try{this.wait();}catch(Exception e){}
        //如果标记不为true，那么往里面存数据。
        this.name=name;
        this.sex=sex;
        flag=true;
        this.notify();//唤醒线程池中第一个等待的线程
    }
    public synchronized void out(){
        if(!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(name+"...."+sex);
        flag=false;
        this.notify();
    }
}
class Input implements Runnable
{
    private Resource r;//为了保证操作的是同一资源，所以把资源对象传参进去
    Input(Resource r){
        this.r=r;
    }
    public void run(){
        int x=0;
        while (true)
        {
            if(x==0)
                r.set("mike","man");            
            else
                r.set("丽丽","女女女女女女");
            x=(x+1)%2;//切换输入内容
        }
    }
}
class Output implements Runnable
{
    private Resource r;
    Output(Resource r){
        this.r=r;
    }
    public void run(){
        while (true)
        {
            r.out();
        }
    }    
}
class ResourceDemo
{
    public static void main(String[] args) 
    {
        Resource r=new Resource();//创建资源对象
        new Thread(new Input(r)).start();//开启两个线程
        new Thread(new Output(r)).start();
    }
}

 (2)、多生产--多消费问题

上面的例子是一个输入一个输出，现在是多个线程执行输入同时多条线程执行输出。即：多个线程操作生产，多个线程操作消费。这是开发中最常见的，希望能够掌握。

class Resource
{
    private String name;
    private int count=1;
    private boolean flag=false;
    public synchronized void set(String name){
        while(flag)//循环判断标记来防止线程等待被唤醒后往下执行，直接生产覆盖上一个数据。
            try{this.wait();}catch(Exception e){}
        this.name=name+"....."+count++;
        System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);
        flag=true;
        this.notifyAll();//唤醒线程池中的全部线程
    }
    public synchronized void out(){
        while(!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"----消费者-------"+this.name);
        flag=false;
        this.notifyAll();//唤醒线程池中的全部线程
    }
}
class Producer implements Runnable
{
    private Resource r;
    Producer(Resource r){
        this.r=r;
    }
    public void run(){
        while (true)
        {
            r.set("商品");
        }
    }
}
class Consumer implements Runnable
{
    private Resource r;
    Consumer(Resource r){
        this.r=r;
    }
    public void run(){
        while (true)
        {
            r.out();
        }
    }
}
class  ProducerConsumerDemo
{
    public static void main(String[] args) 
    {
        Resource r=new Resource();
        new Thread(new Producer(r)).start();
        new Thread(new Producer(r)).start();
        new Thread(new Consumer(r)).start();
        new Thread(new Consumer(r)).start();

    }
}

七、线程间通信-生产者消费者JDK1.5升级版

　　上面的程序虽然能够解决问题，但是发现每次都唤醒全部线程，这样会导致线程都去抢夺cpu执行权，效率有点低，所以JDK在升级1.5的时候推出了一个接口Lock接口。它的出现就替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。同时更为灵活，可以一个锁上加上多组监视器。。

　　在之前的版本中使用Object类中wait、notify、notifyAll的方法来完成的，那是因为同步中的锁是任意对象，所以操作时的等待唤醒的方法是都是定义在Object类中。而现在锁是指定对象Lock，所以查找等待唤醒机制方式需要通过Lock接口来完成.而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方法又单独的封装了一个对象中，这个对象就是Condition，将Object中的三个方法进行了单独的封装，并提供了功能一致的方法await()、signal()、signalAll()。所以Condition接口出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象，可以任意锁进行组合。

Lock接口

Lock lock=new ReentrantLock();//创建Lock对象
void    lock();//获取锁。
void    unlock();//释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在finally中。
4 Condition　　newCondition();//获取Condition对象

 Condition接口

void    await();//对应于Object中的wait方法
void    signal();//对应于Object中的notify方法
void    signalAll();//对应于Object中的notifyAll方法

 JDK1.5多生产--多消费问题代码

import java.util.concurrent.locks .*;
class Resource
{
    private boolean flag;
    private Lock lock=new ReentrantLock();//创建Lock对象
    private Condition procondition=lock.newCondition();//创建Condition对象
    private Condition concondition=lock.newCondition();
    private int count=1;
    private String name;
    public void set(String name){
        lock.lock();//显示的加锁
        try
        {
            while(flag)
                procondition.await();//await替换了wait；
            this.name=name+"..."+count++;
            System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);
            flag=true;
            concondition.signal();//signal替换了notify
        }
        catch (Exception e)
        {
            System.out.println(e);
        }
        finally{
            lock.unlock();//释放锁，释放资源的动作一定要放在finally块中
        }
        
    }
    public void out(){
        lock.lock();
        try
        {
            while(!flag)
                concondition.await();
            System.out.println(Thread.currentThread().getName()+"------消费者-----"+this.name);
            flag=false;
            procondition.signal();
        }
        catch (Exception e)
        {
            System.out.println(e);
        }
        finally{
            lock.unlock();
        }
    }
}
class Producer implements Runnable
{
    private Resource r;
    Producer(Resource r){
        this.r=r;
    }
    public void run(){        
        while (true)
        {            
            r.set("商品");
        }
    }
}
class Consumer implements Runnable
{
    private Resource r;
    Consumer(Resource r){
        this.r=r;
    }
    public void run(){
        while (true)
        {
            r.out();
        }
    }
}
class ProducerConsumerDemo2 
{
    public static void main(String[] args) 
    {
        Resource r=new Resource();
        new Thread(new Producer(r)).start();
        new Thread(new Producer(r)).start();
        new Thread(new Consumer(r)).start();
        new Thread(new Consumer(r)).start();
    }
}

八、Thread类中其他方法

1、停止线程

查看API发现线程停止方法stop方法已经过时了，所以我们无法在使用。其实让线程停止的原理就是：run方法结束。

开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。

所以run方法中通常定义循环，指定控制住循环线程即可结束。

特殊情况：当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。Thread类提供该方法 interrupt()，interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CPU的执行资格。强制动作会发生InterruptedException，一定要记得处理。

class StopThread implements Runnable{
       private boolean flag = true;
       public void run(){
             while(flag ){
                  System. out.println(Thread.currentThread().getName() + "...");
            }
       }
       public void setFlag(){
             flag = false ;
       }
}
 
class StopThreadDemo{
       public static void main(String[] args){
            StopThread st = new StopThread();
            new Thread(st).start();
            new Thread(st).start();        

             int num = 0;
            while(true){
                   if(num++ == 50){
                        st.setFlag();
                         break;
                  }
                  System. out.println(Thread.currentThread().getName()+"..."+ num);
             }
             System. out.println("over" );
      }
}

class StopThread implements Runnable{
       private boolean flag = true;
       public synchronized void run(){
             while(flag){
                   try{
                        wait();
                  } catch(Exception e){
                        System.out.println(e);
                        flag = false;
                  }
                  System.out.println(Thread.currentThread().getName() );
            }
      }
       public void setFlag(){
            flag = false;
      }
}

class StopThreadDemo{
       public static void main(String[] args){
            StopThread st = new StopThread();
            Thread t1 = new Thread(st).start();
            Thread t2 = new Thread(st).start();    
             int num = 0;
             while(true){
                   if(num++ == 50){
                        t1.interrupt();
                        t2.interrupt();
                         break;
                  }
                  System.out.println( Thread.currentThread().getName()+"..." + num);
            }
            System.out.println( "over");
      }
}

2、守护线程

setDaemon，将该线程标记为守护线程或用户线程。正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。 setDaemon(boolean):将线程标记为后台线程，后台线程和前台线程一样，开启，一样抢执行权运行，只有在结束时，有区别，当前台线程都运行结束后，后台线程会自动结束。

3、join方法

当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。join可以用来临时加入线程执行。

4、 setPriority方法 

用来设置优先级

MAX_PRIORITY 最高优先级10

MIN_PRIORITY   最低优先级1

NORM_PRIORITY 分配给线程的默认优先级

5、yield方法

暂停当前线程，让其他线程执行，可以让线程释放执行权

6、toString方法

返回该线程的字符串表示形式，包括线程名称、优先级和线程组