黑马程序员 java面向对象<四> 多线程

最新推荐文章于 2021-10-24 10:52:01 发布

吃番茄不吃番茄皮

最新推荐文章于 2021-10-24 10:52:01 发布

阅读量694

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/kubZhaiNan/article/details/35786945

版权

Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

---------- android培训、java培训、期待与您交流！ ----------

一、多线程

进程是什么

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

线程是什么

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

线程负责的是应用程序的执行顺序。

一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序。

java中的线程

在java中，JVM虚拟机启动时，会有一个进程为java.exe，该程序中至少有一个线程负责java程序的执行。

而且该程序运行的代码存在于main方法中，该线程称之为主线程。其实，JVM启动时不止有一个线程（主线程）

由于java是具有垃圾回收机制的，所以，在进程中，还有负责垃圾回收机制的线程。

二、创建线程的方式

方式一继承Thread类

/**
第一、定义类继承Thread。

第二、复写Thread类中的run方法。

第三、调用线程的start方法。分配并启动该子类的实例。

          start方法的作用：启动线程，并调用run方法。
*/  

class Demo extends Thread  
{  
    public void run()  
    {  
        for (int i=0;i<60;i++)  
            System.out.println(Thread.currentThread().getName() + "demo run---" + i);  
    }  
}   
public class Temp
{  
	public static void main(String[] args)   
	{  
		Demo d1 = new Demo();//创建一个对象就创建好了一个线程  
		
		d1.start();//开启线程并执行run方法  
			
	}  
}

Run方法与start方法的区别：

Run：是让自定义代码存储，让线程运行。

start：启运线程调用方式，调用Run方法

发现运行结果，每一次都不一样因为多个线程，都在获取CPU的执行权，CPU执行到谁，谁就运行。

明确一点，在某一时刻，只能有一个程序在运行，（多核除外）

CPU在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象的把多线程的运行，形容为：在互相抢CPU的资源，这就是多线程的特性：随机性。就是谁抢到，谁运行，至于执行多长时间，CPU说了算。

为什么要覆盖Run方法呢、

Thread类用于描述线程。

该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是Run方法

也就是说：Thread类中的Run方法，用于存储线程要运行的代码。

创建线程方式二：实现Runnable接口

/**
第一、定义类实现Runnable接口。

第二、覆盖Runnable接口中的run方法。

第三、通过Thread类建立线程对象。要运行几个线程，就创建几个对象。

第四、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

第五、调用Thread类的start方法开启线程，并调用Runnable接口子类的run方法。
*/  

//多个窗口同时卖票  
class Ticket implements Runnable  
{  
	private int tic = 10;  
    public void run()  
	{  
		while(true)  
		{  
			if (tic > 0)  
				System.out.println(Thread.currentThread().getName() + "sale:" + tic--);  
		}  
	}  
}  
public class Temp
{  
	 public static void main(String[] args)   
    {  
        Ticket t = new Ticket();  
        Thread t1 = new Thread(t);//创建一个线程  
        Thread t2 = new Thread(t);//创建一个线程  
       
        t1.start();  
        t2.start();  
       
    }  
}

继承Thread 和实现Runnable区别：

实现方式好处：避免了单线程的局限性

在定义线程时，建议使用（实现方式）Runnable线程方式

区别

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

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

三、线程状态运行图

图解

阻塞状态：具备运行资格，但是没有执行权，必须等到cpu的执行权，才转到运行状态。

冻结状态：放弃了cpu的执行资格，cpu不会将执行权分配给这个状态下的线程，必须被唤醒后，此线程要先转换到阻塞状态

等待cpu的执行权后，才有机会被执行到。

四、多线程安全问题

线程同步

同步的前提：

1、同步需要两个或者两个以上的线程

2、多个线程使用的是同一个锁。

3、未满足这两个条件，不能称其为同步。

同步的弊端

当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

/*
银行：有一个金库

* 有两个储户分别存300元，每次存100，存3次
*
* 目的：该程序是否有安全问题《如果有，如何解决？》
*
* 如何找问题：
* 1，明确哪些代码是多线程运行代码
* 2，明确共享数据
* 3，明确多线程运行代码中哪些语句是操作共享数据的。、
*
* 同步数据方法，可以放在函数上
*/
class Bank  
{  
    private int sum;  
    public synchronized void Add(int num)  
    {  
        sum = sum + num;  
        System.out.println(Thread.currentThread().getName()+"sum:"+sum);  
    }  
}  
class Cus implements Runnable  
{  
    private Bank b = new Bank();  
    public void run()  
    {  
        for(int x=0;x<3;x++)  
        {  
            b.Add(100);  
        }  
    }  
}  
  
public class Temp {  
      
    public static void main(String[]args)  
    {  
        Cus c = new Cus();  
        Thread t1 = new Thread(c);  
        Thread t2 = new Thread(c);  
        t1.start();  
        t2.start();  
    }  
  
}

同步代码块

/*
通过分析，发现，打印出0，-1，-2等错票。
多线程的运行出现了安全问题。
问题的原因：
    当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
    另一个线程参与进来执行。导致共享数据的错误。
解决办法：
    对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized(对象)
{
    需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
*/
class Ticket implements Runnable  
{  
    private  int tick = 1000;  
    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--);  
                }  
            }  
        }  
    }  
}  
  
  
class  Temp
{  
    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.
*
* 通过该程序进行验证
*
* 使用两个线程来卖票
* 一个线程在同步代码块中。
* 一个线程在同步函数中。
* 都在执行卖票动物。

* 重点：

* 先让主线程停止10毫秒，当程序执行到t2后，执行一会儿，主线程突然醒了，然后执行主线程


* 如果同步函数被静态修饰后，使用的锁是什么呢？
* 通过验证，发现不再是this.（因为静态方法中也不可以定义this）

* 静态进内存时，内存中没有本类对象，但是一定有该类的字节码文件对象。

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

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

*/
class DemoTecket implements Runnable  
{  
    private int ticket = 100;  
    Object obj = new Object();  
    boolean flag = true;  
  
    public void run()  
    {  
        if(flag)  
        {  
            while(true)  
            {  
                //如果show方法被静态修饰，这里调用的对象是DemoTicket.class  
                synchronized(this)//因为run方法调用的show()方法，show方法调用的是this.所以这里是this  
                {  
                    if(ticket>0)  
                    {  
                        try{Thread.sleep(10);}catch(Exception e){}  
                        System.out.println(Thread.currentThread().getName()+"...同步售票："+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()+"...函数售票："+ticket--);  
            }  
        }  
      
      
}  
public class Temp{  
      
    public static void main(String[]args)  
    {  
        DemoTecket dt = new DemoTecket();  
          
        Thread t1 = new Thread(dt);  
        Thread t2 = new Thread(dt);  
        Thread t3 = new Thread(dt);  
        Thread t4 = new Thread(dt);  
        t1.start();  
        //重点：先让主线程停止10毫秒，当程序执行到t2后，执行一会儿，主线程突然醒了，然后执行主线程  
        try{Thread.sleep(10);}catch(Exception e){}  
        dt.flag=false;  
        t2.start();  
        //t3.start();  
        //t4.start();  
          
    }  
  
}

静态同步函数的锁是class对象

/*

 * 用两个线程进行：卖票

 * 同步函数用的是哪一个锁呢？

 * 函数需要被对象调用，那么函数都有一个所属对象引用。就是this.

 * 所以同步函数使用的锁是this.

 * 如何找问题：

 * 1，明确哪些代码是多线程运行代码

 * 2，明确共享数据

 * 3，明确多线程运行代码中哪些语句是操作共享数据的。、

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

 
 * 通过验证，发现不在是this，因为静态方法中，不可以定义this

 * 我们可以这样想，

 * 静态进入内存的时候，是没有本类对象的，首先加载的是“类” 所以一定会有该类对应的字节码文件对象(类名.class)

 * 类进入内存，会建立一个字节码文件对象。

 * 由此推断-->被静态修饰的同步方法锁：用的是class（类）

 * 静态的同步方法，使用的锁是该方法所在的字节码文件对象.  类名.class


 */
class TicketDemo implements Runnable  
{  
    //将票私有500张票  
    private static int tick = 100;  
      
    //定义一个标记，用来调用两个线程  
    boolean flag = true;  
      
    //覆盖runnable中的run方法  
    public void run()  
    {  
        if(flag)  
        {  
            //打印车票  
            while(true)  
            {  
                  
                //如果show方法被静态修饰，这里调用的对象是Ticket.class  
                synchronized(TicketDemo.class)//因为run方法调用的show()方法，show方法调用的是this.所以这里是this  
                {  
                    if(tick>0)  
                    {  
                        try{Thread.sleep(10);}catch(Exception e){}  
                        System.out.println(Thread.currentThread().getName()+"同步售票"+tick--);  
                    }  
                }  
            }  
        }  
        else  
            while(true)  
                show();  
    }  
      
    //对操作共享数据的代码块进行封装  
    public static synchronized void show()  
    {  
        if(tick>0)  
        {  
            try{Thread.sleep(10);}catch(Exception e){}  
            //currentThread();获取线程名称  
            System.out.println(Thread.currentThread().getName()+"..同步函数售票.."+tick--);  
        }  
    }  
      
}  
public class Temp{  
      
    public static void main(String[]args)  
    {  
        TicketDemo t = new TicketDemo();  
          
        //创建线程  
        Thread t1 = new Thread(t);  
        Thread t2 = new Thread(t);  
          
        t1.start();  
          
          
        //当主函数执行到这儿时，让它停留10秒;原因是，main主函数线程会瞬间将两个线程开启执行，  
        //所以当线程执行到t.falg=false时，会直接执行到show方法  
        try{Thread.sleep(10);}catch(Exception e){}  
        t.flag = false;  
        t2.start();  
          
    }  
}

线程死锁

//定义锁的对象  
class Dea implements Runnable  
{  
    //定义一个标记  
    private boolean flag;  
      
    //初始化  
    Dea(boolean flag)  
    {  
        this.flag = flag;  
    }  
      
    //覆盖Run方法  
    public void run()  
    {  
        //创建同步锁，并互相嵌套  
        if(flag)  
        {  
            synchronized(Lock.lockA)  
            {  
                System.out.println("Lock.lockA");  
                synchronized(Lock.lockB)  
                {  
                    System.out.println("Lock.lockB");  
                }  
            }  
        }  
        else  
        {  
            synchronized(Lock.lockB)  
            {  
                System.out.println("Lock.lockB");  
                synchronized(Lock.lockA)  
                {  
                    System.out.println("Lock.lockA");  
                }  
            }  
        }  
    }  
}  
  
//创建锁对象  
//加static：原因是可以直接用类名.lock访问  
class Lock  
{  
    static Object lockA = new Object();  
    static Object lockB = new Object();  
}  
public class Temp {  
      
    public static void main(String[]args)  
    {  
        Thread t1 = new Thread(new Dea(true));  
        Thread t2 = new Thread(new Dea(false));  
          
        t1.start();  
        t2.start();  
    }  
  
}

线程间通信

多线程间通信是线程之间进行交互的方式，简单说就是存储资源和获取资源。比如说仓库中的货物，有进货的，有出货的。

还比如生产者和消费者的例子。这些都可以作为线程通信的实例。那么如何更好地实现通信呢？先看下面的代码：

/* 
线程间通信： 
 
 
生产者消费者  多个 
 
*/  
import java.util.concurrent.locks.*;  
  
class ProducerConsumerDemo{  
    public static void main(String[] args){  
        Resouse r = new Resouse();  
        Producer p = new Producer(r);  
        Consumer c = new Consumer(r);  
        Thread t1 = new Thread(p);  
        Thread t2 = new Thread(c);  
        Thread t3 = new Thread(p);  
        Thread t4 = new Thread(c);  
        t1.start();  
        t2.start();  
        t3.start();  
        t4.start();  
    }  
}  
  
class Resouse{  
    private String name;  
    private int count = 1;  
    private boolean flag =  false;   
    private Lock lock = new ReentrantLock();  
    private Condition condition_P = lock.newCondition();  
    private Condition condition_C = lock.newCondition();  
//要唤醒全部，否则都可能处于冻结状态，那么程序就会停止。这和死锁有区别的。  
    public void set(String name)throws InterruptedException{  
        lock.lock();  
        try{  
            while(flag)//循环判断，防止都冻结状态  
                condition_P.await();  
            this.name = name + "--" + count++;  
            System.out.println(Thread.currentThread().getName() + "..生成者--" + this.name);  
            flag = true;  
            condition_C.signal();  
        }finally{  
            lock.unlock();//释放锁的机制一定要执行  
        }         
    }  
    public void out()throws InterruptedException{  
        lock.lock();  
        try{  
            while(!flag)//循环判断，防止都冻结状态  
                condition_C.await();  
            System.out.println(Thread.currentThread().getName() + "..消费者." + this.name);  
            flag = false;  
            condition_P.signal();//唤醒全部  
        }finally{  
            lock.unlock();  
        }  
    }  
}  
  
class Producer implements Runnable{  
    private Resouse r;  
    Producer(Resouse r){  
        this.r = r;  
    }  
    public void run(){  
        while(true){  
            try{  
                r.set("--商品--");  
            }catch (InterruptedException e){}  
        }  
    }  
}  
  
class Consumer implements Runnable{  
    private Resouse r;  
    Consumer(Resouse r){  
        this.r = r;  
    }  
    public void run(){  
        while(true){  
            try{  
                r.out();  
            }catch (InterruptedException e){}  
        }  
    }  
}

JDK1.5中升级Lock

/* 
 * Lock：锁
 * ReentrantLock: 重复锁定
 * Lock lock = new ReentrantLock();//Lock类下的子类对象，创建可重复使用的锁
 *   |--lock：锁定...相当于synchronized
 *   |--unlock：释放锁
 * condition：条件、身份
 *   |--await：等待
 *   |--signal：发送信号，唤醒一个等待线程
 *   |--signalAll：唤醒所有等待线程
 

 * InterruptedException:中断异常

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

 * 将同步Synchronized替换成显示Lock操作。

 * 将Object中的wait\notify()\notifyAll,替换成了Condition对象

 * 该对可以Lock锁，进行获取，同时可以创建多个锁对象

 * 在该实例中，实现了本方只唤醒对方的操作。

*/  
import java.util.concurrent.locks.*;
class Ress  
{  
    private String name;  
    private String sex;  
    boolean flag = false;  
      
    //Lock类下的子类对象，创建可重复使用的锁  
    private Lock lock = new ReentrantLock();  
    //返回绑定到此Lock实例的新Condition实例    其实就是可以建立多个身份的锁  
    Condition condition_pro = lock.newCondition();//生产锁对象  
    Condition condition_con = lock.newCondition();//消费锁对象  
      
    public void set(String name,String sex)throws InterruptedException  
    {  
        lock.lock();  
        try  
        {  
            while(flag)  
            {  
                condition_pro.await();//生产锁等待  
            }  
            this.name = name;  
            this.sex = sex;  
            flag = true;  
            condition_con.signal();//唤醒消费  
        }  
        finally  
        {  
            lock.unlock();//释放锁的动作，一定要执行。  
        }  
    }  
    public void out()throws InterruptedException  
    {  
        lock.lock();  
        try  
        {  
            while(!flag)  
            {  
                condition_con.await();//消费锁等待  
            }  
            System.out.println(this.name+".."+this.sex);  
            flag = false;  
            condition_pro.signal();//唤醒生产  
        }  
        finally  
        {  
            lock.unlock();  
        }  
    }  
}  
class Inputt implements Runnable  
{  
    private Ress r;  
    Inputt(Ress r)  
    {  
        this.r = r;  
    }  
    public void run()  
    {  
        int x = 0;  
  
        while(true)  
        {  
            try  
            {  
                if(x==0)  
                {  
                    r.set("MIKE", "Man");  
                }  
                else  
                {  
                    r.set("麦克", "女");  
                }  
                x=(x+1)%2;  
            }  
            catch(InterruptedException e)  
            {}  
        }  
    }  
}  
class Outt implements Runnable  
{  
    private Ress r;  
    Outt(Ress r)  
    {  
        this.r = r;  
    }  
    public void run()  
    {  
        try  
        {  
            while(true)  
            {  
                r.out();  
            }  
        }  
        catch(InterruptedException e)  
        {}  
    }  
}  
public class Temp {  
      
    public static void main(String[]args)  
    {  
        Resours res = new Resours();  
          
        Producer pro = new Producer(res);  
        Consumer con = new Consumer(res);  
          
        Thread t1 = new Thread(pro);  
        Thread t2 = new Thread(pro);  
        Thread t3 = new Thread(con);  
        Thread t4 = new Thread(con);  
        t1.start();  
        t2.start();  
        t3.start();  
        t4.start();  
    }  
  
}