黑马程序员——Java基础---多线程

一、多线程概述

        要理解多线程，就必须理解线程。而要理解线程，就必须知道进程。

1、 进程

        是一个正在执行的程序。例如，qq等

        每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。//例如登录qq，你需要输入账号、密码、点击登录等

2、线程

         就是进程中的一个独立的控制单元。线程在控制着进程的执行。只要进程中有一个线程在执行，进程就不会结束。//登录qq时，会验证密码账号等线程

        一个进程中至少有一个线程。即  进程：线程=1：n（n为大于等于1的整数）

3、多线程

        在java虚拟机启动的时候会有一个java.exe的执行程序，也就是一个进程。该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。JVM启动除了执行一个主线程，还有负责垃圾回收机制的线程。像这种在一个进程中有多个线程执行的方式，就叫做多线程。

4、多线程存在的意义

        多线程的出现能让程序产生同时运行效果。可以提高程序执行效率。

         例如：在java.exe进程执行主线程时，如果程序代码特别多，在堆内存中产生了很多对象，而同时对象调用完后，就成了垃圾。如果垃圾过多就有可能是堆内存出现内存不足的现象，只是如果只有一个线程工作的话，程序的执行将会很低效。而如果有另一个线程帮助处理的话，如垃圾回收机制线程来帮助回收垃圾的话，程序的运行将变得更有效率。现实生活中，你可以一边烧水，一边切菜，为了做汤。

5、计算机CPU的运行原理

         我们电脑上有很多的程序在同时进行，就好像cpu在同时处理这所以程序一样。但是，在一个时刻，单核的cpu只能运行一个程序。而我们看到的同时运行效果，只是cpu在多个进程间做着快速切换动作。就好像灯泡一样，它是在不停的闪灭，而我们眼睛接受不全，便以为是一直亮。

         而cpu执行哪个程序，是毫无规律性的。这也是多线程的一个特性：随机性。哪个线程被cpu执行，或者说抢到了cpu的执行权，哪个线程就执行。而cpu不会只执行一个，当执行一个一会后，又会去执行另一个，或者说另一个抢走了cpu的执行权。至于究竟是怎么样执行的，只能由cpu决定。就好像皇帝跟妃子的关系。

 

二、创建线程的方式

        创建线程共有两种方式：继承方式和实现方式（简单的说）。

1、 继承方式

        通过查找java的帮助文档API，我们发现java中已经提供了对线程这类事物的描述的类——Thread类。这第一种方式就是通过继承Thread类，然后复写其run方法的方式来创建线程。

创建步骤：

        a，定义类继承Thread。

        b，复写Thread中的run方法。

             目的：将自定义代码存储在run方法中，让线程运行。

        c，创建定义类的实例对象。相当于创建一个线程。

        d，用该对象调用线程的start方法。该方法的作用是：启动线程，调用run方法。

注：如果对象直接调用run方法，等同于只有一个线程在执行，自定义的线程并没有启动。

覆盖run方法的原因：

        Thread类用于描述线程。该类就定义了一个功能，用于存储线程要执行的代码。该存储功能就run方法。也就是说，Thread类中的run方法，用于存储线程要运行的代码。

程序示例：

/*

创建两个线程 贡献一个 资源，
加入主线程  便有三个线程
*/
class Demo extends Thread//继承Thread类
{
     public int x=60;//定义计数器
    public Demo(String name)
    {
        super(name);
    }
    public void run()//复写run方法
    {

        while(x>0)
        {
            System.out.println(Thread.currentThread().getName()+".....sale:"+"...."+x);//获取线程名称以及对应的次数
                    x--;
        }
    }
}
class ThreadDemo
{
    public static void main(String[] args)
    {
        Demo d=new Demo("--one--");//创建线程名称
        Thread d1=new Thread(d);//共用一个资源的两个线程
        Thread d2=new Thread(d);
        
        d1.start();//start（）方法可以调用run（）方法 实现多线程
        d2.start();

        
            for(int x=0;x<60;x++)//主线程  打印  main
            {
                System.out.println("---main---"+x);
            }
        
    }
}

程序运行结果每一次都可能出现不同种的情况，而下图出现的次序错乱问题，应该是计算机为多核，打印到显示台上才会如此。如图：

第二种方式：实现Runnable接口：

/*
需求：简单的卖票程序。
多个窗口同时买票。


创建线程的第二种方式：实现Runable接口

步骤：
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法。
    将线程要运行的代码存放在该run方法中。

3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
    为什么要将Runnable接口的子类对象传递给Thread的构造函数。
    因为，自定义的run方法所属的对象是Runnable接口的子类对象。
    所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。


5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。



实现方式和继承方式有什么区别呢？

实现方式好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式。

两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。




*/

class Ticket implements Runnable//extends Thread
{
    private  int tick = 100;//有一百张票
    public void run()
    {
        while(true)
        {
            if(tick>0)
            {
                System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);//打印线程名称跟票数
            }
            else
                break;
        }
    }
}


class  TicketDemo
{
    public static void main(String[] args) 
    {

        Ticket t = new Ticket();

        Thread t1 = new Thread(t);//创建了一个线程；
        Thread t2 = new Thread(t);//创建了一个线程；
        Thread t3 = new Thread(t);//创建了一个线程；
        Thread t4 = new Thread(t);//创建了一个线程；
        t1.start();//运行该线程，调用run()方法
        t2.start();
        t3.start();
        t4.start();


        /*
        Ticket t1 = new Ticket();
        //Ticket t2 = new Ticket();
        //Ticket t3 = new Ticket();
        //Ticket t4 = new Ticket();

        t1.start();
        t1.start();
        t1.start();
        t1.start();
        */

    }
}

三、两种方式的区别和线程的几种状态

1、两种创建方式的区别

        继承Thread：线程代码存放在Thread子类run方法中。

        实现Runnable：线程代码存放在接口子类run方法中。      

2、几种状态

        被创建：等待启动，调用start启动。

         运行状态：具有执行资格和执行权。

         临时状态（阻塞）：有执行资格，但是没有执行权。

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

         消忙状态：stop（）方法，或者run方法结束。

注：当已经从创建状态到了运行状态，再次调用start（）方法时，就失去意义了，java运行时会提示线程状态异常。

四、线程安全问题

/*
通过分析，发现，打印出0，-1，-2等错票

多线程的运行出现了问题
问题的原因：
        当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
        另一个线程参与进来执行。导致共享数据的错误

解决办法：
        对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。


java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块
synchronized(对象)
{
    需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有 获取锁

火车上的卫生间----经典

同步的前提：
1    必须要有两个或者两个以上的线程
2    必须是多个线程使用同一个锁


必须保证同步中只能有一个线程在运行

好处：    解决了多线程的安全问题

弊端：    多个线程需要判断锁，较为消耗资源 


*/

class Ticket implements Runnable
{
    private int tick=100;
    Object obj =new Object();
    public void run()
    {
        while(true)
        {
            synchronized(obj)//加锁，锁可以是任意存在的对象
            {
                if(tick>0)
                {
                    //try{Thread.sleep(10);}catch(Exception e){}//线程暂时休眠
                    System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);//打印线程名称和票编号
                }
                else 
                    break;
            }
        }
    }
}
class TicketDemo2
{
    public static void main(String[] args)
    {
        
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        Thread t4 = new Thread(t);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

五、静态函数的同步方式

如果同步函数被静态修饰后，使用的锁是什么呢？

        通过验证，发现不在是this。因为静态方法中也不可以定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。如：

        类名.class 该对象的类型是Class

这就是静态函数所使用的锁。而静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class

经典示例：

/*
单例设计模式。


*/
//饿汉式
class Single
{
    private static final Single s=new Single();//创建Single类并分配资源
    private  Single(){}
    public static Single getInstance()
    {
        return s;
    }
}


//懒汉式
class Single
{
    private static Single s=null;//创建Single类，使其为空
    private Single(){}
    public static Single getInstance()
    {
        if (s==null)
        {
            synchronized(Single.class)//Single.class文件在类创建时，便存在
            {
                if(s==null)
                    s=new Single();//分配资源
            }
        }
        return s;
    }
}

六、死锁

        当同步中嵌套同步时，就有可能出现死锁现象。

/*
死锁
同步中嵌套同步。A锁套B锁，B锁套A锁。
*/
class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag = flag;
    }

    public void run()
    {
        if(flag)
        {
            while(true)
            {
                synchronized(MyLock.locka)//A锁
                {
                    System.out.println(Thread.currentThread().getName()+"...if locka ");
                    synchronized(MyLock.lockb)//B锁
                    {
                        System.out.println(Thread.currentThread().getName()+"..if lockb");                    
                    }
                }
            }
        }
        else
        {
            while(true)
            {
                synchronized(MyLock.lockb)//Ｂ锁
                {
                    System.out.println(Thread.currentThread().getName()+"..else lockb");
                    synchronized(MyLock.locka)//A锁
                    {
                        System.out.println(Thread.currentThread().getName()+".....else locka");
                    }
                }
            }
        }
    }
}


class MyLock//创建两个锁
{
    static Object locka = new Object();
    static Object lockb = new Object();
}

class  DeadLockTest
{
    public static void main(String[] args) 
    {
        Thread t1 = new Thread(new Test(true));//创建两个线程
        Thread t2 = new Thread(new Test(false));
        t1.start();//运行线程，调用run()方法
        t2.start();
    }
}

死锁运行程序 结果如下图：

七、线程间通信

        其实就是多个线程在操作同一个资源，但是操作的动作不同。如一个 存入，一个输出。

1、使用同步操作同一资源的示例：

/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。

*/
class Res//定义资源 包括姓名 性别  以及否的初设定
{
    String name;
    String sex;
    boolean flag = false;
}

class Input implements Runnable//存入  继承Runnable
{
    private Res r ;
    Input(Res r)
    {
        this.r = r;
    }
    public void run()//复写run方法
    {
        int x = 0;//定义变量，改变存入资源的种类
        while(true)
        {
            synchronized(r)//锁
            {

                if(r.flag)//当有资源。flag为真时，先等待，避免多存
                    try{r.wait();}catch(Exception e){}
                if(x==0)
                {
                    r.name="mike";
                    r.sex="man";
                }
                else
                {
                    r.name="丽丽";
                    r.sex = "女女女女女";
                }
                x = (x+1)%2;//改变x的奇偶
                r.flag = true;//改变flag的值，说明已存
                r.notify();//唤醒其他线程
            }
        }
    }
}

class Output implements Runnable//输出    继承Runnable
{
    private Res r ;
    
    Output(Res r)
    {
        this.r = r;
    }
    public void run()//复写run方法
    {
        while(true)
        {
            synchronized(r)//锁
            {
                if(!r.flag)//当flag为假时，即没有资源时，先等待
                    try{r.wait();}catch(Exception e){}
                System.out.println(r.name+"...."+r.sex);//打印资源
                r.flag = false;//改变flag的值，说明已取出
                r.notify();//唤醒其他线程
            }
        }
    }
}


class  InputOutputDemo
{
    public static void main(String[] args) 
    {
        Res r = new Res();

        Input in = new Input(r);
        Output out = new Output(r);

        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);

        t1.start();
        t2.start();
    }
}


//notifyAll();

/*
wait:
notify();
notifyAll();

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

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

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。


*/

程序运行部分截图如下：

 几个小问题：

        1）wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中？

                a，这些方法存在与同步中。

                b，使用这些方法时必须要标识所属的同步的锁。同一个锁上wait的线程，只可以被同一个锁上的notify唤醒。

                c，锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。

        2）wait(),sleep()有什么区别？

              wait():释放cpu执行权，释放锁。

              sleep():释放cpu执行权，不释放锁。

        3）为甚么要定义notifyAll？

        因为在需要唤醒对方线程时。如果只用notify，容易出现只唤醒本方线程的情况。导致程序中的所以线程都等待。

2、JDK1.5中提供了多线程升级解决方案。

        将同步synchronized替换成显示的Lock操作。将Object中wait，notify，notifyAll，替换成了Condition对象。该Condition对象可以通过Lock锁进行获取，并支持多个相关的Condition对象。

升级解决方案的示例：

import java.util.concurrent.locks.*;

class ProducerConsumerDemo2 
{
    public static void main(String[] args) 
    {
        Resource r = new Resource();//建立资源

        Producer pro = new Producer(r);//创建生产者与消费者，操作的是同一个资源
        Consumer con = new Consumer(r);

        Thread t1 = new Thread(pro);//生产者两个线程
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);//消费者两个线程
        Thread t4 = new Thread(con);

        t1.start();//运行线程，调用run()方法
        t2.start();
        t3.start();
        t4.start();

    }
}

/*
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。
Lock:替代了Synchronized
    lock 
    unlock
    newCondition()

Condition：替代了Object wait notify notifyAll
    await();
    signal();
    signalAll();
*/
class Resource
{
    private String name;//创建资源固有属性
    private int count = 1;
    private boolean flag = false;
            //  t1    t2
    private Lock lock = new ReentrantLock();//创建锁

    private Condition condition_pro = lock.newCondition();//将锁的情况 分为两份，线程使用的是自己派别的锁
    private Condition condition_con = lock.newCondition();



    public  void set(String name)throws InterruptedException
    {
        lock.lock();
        try
        {
            while(flag)//flag  为真时，代表有资源
                condition_pro.await();//t1,t2  生产者等待
            this.name = name+"--"+count++;

            System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);//打印线程信息到控制台上
            flag = true;
            condition_con.signal();//唤醒消费者
        }
        finally
        {
            lock.unlock();//释放锁的动作一定要执行。
        }
    }


    //  t3   t4  
    public  void out()throws InterruptedException
    {
        lock.lock();
        try
        {
            while(!flag)//flag 为假时， 代表没有资源
                condition_con.await();//消费者等待
            System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);//打印线程信息到控制台上
            flag = false;
            condition_pro.signal();//唤醒生产者
        }
        finally
        {
            lock.unlock();//释放锁
        }
        
    }
}

class Producer implements Runnable//生产者的类，继承Runnable
{
    private Resource res;

    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()  //复写run()方法
    {
        while(true)
        {
            try
            {
                res.set("+商品+");  //在资源中增加商品
            }
            catch (InterruptedException e)
            {
            }
            
        }
    }
}

class Consumer implements Runnable//消费者的类，继承Runnable
{
    private Resource res;

    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()//复写 run()方法
    {
        while(true)
        {
            try
            {
                res.out();//移除资源
            }
            catch (InterruptedException e)
            {
            }
        }
    }
}

改程序运行结果部分截图如下：

八、停止线程

/*
stop方法已经过时

如何停止线程？
只有一种，run方法结束
开启多线程运行，运行代码通常是循环结构

只要控制住循环，就可以让run方法结束，也就是线程结束
就是将while等判断语句中加入限制条件让其运行一段时间后停止运行

特殊情况：
当线程处于冻结状态就不会读取到标记。那么线程就不会结束
例如线程就如等待状态，没有其他唤醒线程，将会导致线程运行不到后面的结束 语句

当没有指定的方式让冻结的线程恢复到运行状态时，就需要对冻结了的线程进行清除
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

强制的方法为中断  interrupt();   
例如
当主函数运行将要结束时，使进入冻结状态的t1进程，强制将其终止
t1.interrupt();


*/


/*
该函数有三个线程，主线程和t1和t2两个线程。  两个线程中while可能会进入死循环，需要强制结束，
第一种方法：    通过调用，是while中的条件不满足，这时程序会结束
第二种方法：    使用中断函数interrupt();
*/
class StopThread implements Runnable
{
    private boolean flag =true;
    public  void run()
    {
        while(flag)
        {
            
            System.out.println(Thread.currentThread().getName()+"....run");
        }
    }
    public void changeFlag()
    {
        flag = false;
    }
}




class  StopThreadDemo
{
    public static void main(String[] args) 
    {
        StopThread st = new StopThread();//新建停止线程
        
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(st);


        //t1.setDaemon(true);//设置为守护线程，
        //t2.setDaemon(true);
        t1.start();
        t2.start();

        int num = 0;

        while(true)
        {
            if(num++ == 60)
            {
                st.changeFlag();//当满足条件时改变Flag状态，使线程结束
                //t1.interrupt();////清除冻结状态 ，唤醒线程
                //t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+"......."+num);
        }
        System.out.println("over");
    }
}

程序运行结果部分截图如下：

扩展小知识：

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

即在主函数中，出现t1.join()时，只能等t1线程执行完成后，才能执行主函数中的线程
如果在t1线程中加入了  t2.join()时，只能等t2线程执行完成后，才能执行主函数中的线程

注意：   t1.join()如果在主函数中出现，只与t1和主线程有关

当t1有可能进入冻结状态时，可以使其中断，之后便可以执行主函数。
    假使又使t1唤醒进入执行状态，将出现  异常




同步的线程中   cpu决定哪个线程将会执行，然而执行将会有一个频率，就是线程具有优先级

从1到10；默认线程的优先级为5；10为最高，1为最低；
因为是常量  为了阅读性 MAX_PRIORITY     max_priority
                        MIN_PRIORITY    min_priority
                        MORM_PRIORITY    morm_priority
        改变线程的优先级        t1.setPriority(Thread.MAX_PRIORITY);

MAX_PRIORITY 
MIN_PRIORITY
MORM

Thread.yield();   线程休息一下，将cpu的使用权，推给其他线程
Thread.yield();    Thread.yield  thread.yield    
*/
class Demo implements Runnable
{
    public void run()
    {
        for(int x=0;x<70;x++)
        {
            System.out.println(Thread.currentThread+"........"+x);\
            Thread.yield();
            
        }
    }
}
class JoinDemo
{
    public static void main(String[]  args) throws Exception
    {
        Demo d=new Demo();
        Thread t1=new Thread(d);
        Thread t2=new Thread(d);
        t1.start();
        //t1.setPriority(Thread.MAX_PRIORITY);
        t2.start();
        //t1.join();
        for(int x=0;x<80;x++)
        {
            //System.out.println("main...."+x);
        }
        System.out.println("over");
    }

}

自我总结：

     线程的由来是继承Thread或者实现Runnable，单线程可以认为是要做完某事才能做另外一件事，因此很负责很安全，同样的会导致效率比较慢，而多线程，可以看做同时做很多事，因此效率会比较高，但同时可能会带来安全隐患，因此需要用到锁这样的工具。

如果是很多人来做一件事情时，就需要有标记即flag，需要告诉别人，自己完成到哪儿了。

而有时某些人会陷入困境中，做很多无用功，这时需要别人来制止它的行为。即，强制结束。

而某些人会陷入迷茫，无事可做。要么唤醒它，要么结束它。

甚至会有那么一些人陷入内乱，导致无法工作，即死锁。这是我们要避免的情况。

而有些人是为了某些人的存在而存在的。即守护线程。如果某些人不存在了，那么有些人也就没有戏了。

而有些毒瘤的人加入某组织，毒瘤不死，组织无法运行。即  join（）