Java进阶八—多线程

发布时间:2023年12月21日

Java进阶八—多线程

一.?问题的提出

1.一台计算机为何能够执行多个程序?它们是怎么执行多个程序的?

电脑可以同时做很多事情,一边聊天,一边听歌,一边上网查资料等,原因是电脑有多个核心(脑子),一个核心可以做一件事情,多个核心就可以做多件事情。而在很早的时候计算机CPU只有一个核心只能处理一件事情,所以科学家想出了一个办法,假如有两个应用,一个应用不使用时可将这个应用暂停(挂起),使用时打开将另一个应用暂停(挂起)。造成一种假象表面上CPU可以同时运行两个程序,实际上是进程切换的快,第一个进程打开,第二个进程挂起,给你一种错觉。得出:多核CPU可以同时执行多个进程,单核CPU就可以“同时”执行多个进程。

微观上说,多核CPU可以同时执行多个进程,进程数与CPU核数相当。但宏观上说,由于CPU会分时间片执行多个进程,所以实际执行进程个数会远多于CPU核数。

?2.那么核心与进程和线程有什么关系?

粗略理解:核心 > 一个进程或多个进程(同时)?> 一个线程或多个线程

具体理解:腾讯面试题04.进程和线程的区别?_面试题线程和进程-CSDN博客

3.什么是并发和并行与区别??

并发:当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程,它只能把CPU运行时间划分成若干个时间段,再将时间 段分配给各个线程执行,在一个时间段的线程代码运行时,其它线程处于挂起状。.这种方式我们称之为并发(Concurrent)。

并行:当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时,另一个CPU可以执行另一个线程,两个线程互不抢占CPU资源,可以同时进行,这种方式我们称之为并行(Parallel)。

区别:并发和并行是即相似又有区别的两个概念,并行是指两个或者多个事件在同一时刻发生;而并发是指两个或多个事件在同一时间间隔内发生。在多道程序环境下,并发性是指在一段时间内宏观上有多个程序在同时运行,但在单处理机系统中,每一时刻却仅能有一道程序执行,故微观上这些程序只能是分时地交替执行。倘若在计算机系统中有多个处理机,则这些可以并发执行的程序便可被分配到多个处理机上,实现并行执行,即利用每个处理机来处理一个可并发执行的程序,这样,多个程序便可以同时执行。

二.两种方法实现多线程?

1.通过继承Thread类?

package com.thread;

// 继承多线程Thread类
public class DemoTest extends Thread{

   // 重新run方法
   @Override
    public void run() {

       while (true) {
           System.out.println("one");
       }

    }
}
package com.thread;

public class Demo {
    public static void main(String[] args) {
        
        DemoTest demoTest = new DemoTest();
        // start()方法多开启一个线程,然后自动调用run()
        demoTest.start();
        
        while (true) {
            System.out.println("two");
        }
        
    }
}

2.通过实现接口Runnable?

package com.thread;

public class DemoTest implements Runnable{
   // 重新run方法
   @Override
    public void run() {
       while (true) {
           System.out.println("one");
       }
    }
}
package com.thread;

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

        DemoTest demoTest = new DemoTest();

        // 使用接口Runnable,需要创建一个Thread类
        Thread thread = new Thread(demoTest);

        // start()方法多开启一个线程,然后自动调用run()
        thread.start();

        while (true) {
            System.out.println("two");
        }

    }
}

写法二:简化操作以及线程名?

package com.thread;

public class DemoTest implements Runnable{
   // 重新run方法
   @Override
    public void run() {
       while (true) {
           // getName()设置线程名
           System.out.println("one" +Thread.currentThread().getName());
       }
    }
}
package com.thread;

import com.microsoft.bean.Test;

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

        DemoTest demoTest = new DemoTest();

        new Thread(demoTest," Fuck_one").start();

        while (true) {
            System.out.println("two");
        }

    }
}

补充:匿名内部类创建多线程——你们老师喜欢的???

package com.thread;

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

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("one");
                }
            }
        }).start();


        while (true) {
            System.out.println("two");
        }
      
    }
}

三.多线程的执行过程?

  • 一般的程序是从main出发,直线向下进行,只有一条主线
  • 多线程在main主线程序遇到线程程序时会转到线程程序,并返回到主线程序中,这样main程序和线程程序同时执行

?

四.案例,抢鞋

抢鞋的逻辑代码涵盖在线程当中,假设有10双鞋,有三个人来抢,一个线程就是一个用户,所以这就有三个名称不一样的线程名。(三个人抢占共同资源10双鞋)

package com.thread;

public class DemoTest implements Runnable{

    public int nike = 10;

   @Override
    public void run() {
       while (true) {
           if (nike >0 ) {
               System.out.println(Thread.currentThread().getName() +"还剩"+(--nike)+"双鞋");
           }
       }
    }

}
package com.thread;

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

        DemoTest demoTest = new DemoTest();

        new Thread(demoTest,"one").start();
        new Thread(demoTest,"two").start();
        new Thread(demoTest,"three").start();

    }
}

五.后台、守护进程的提出?

?

图中可知线程分为前台线程(应用)与后台进程(后台进程)。

  • 是前台进程,Background processes是后台进程也叫守护进程,这些进程在电脑开机时就被启动,这样电脑才能正常且安全的运作起来,在程序中也是同理
  • 与进程同理,前台线程为用户提供服务,也有后台线程为前台线程提供的服务进行保护或者守护

?后台线程的创建过程

package com.thread;

public class DaemoTest implements Runnable{
    @Override
    public void run() {
        System.out.println("守护线程开启");
    }
}
package com.thread;

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

        DemoTest demoTest = new DemoTest();
        DaemoTest daemoTest = new DaemoTest();
        Thread dThread = new Thread(daemoTest);

        // 后台线程(守护线程)--维护前台线程
        // 开启
        dThread.setDaemon(true);
        dThread.start();
        // 判断是否开启
        System.out.println(dThread.isDaemon());


        // 前台线程--应用
        new Thread(demoTest,"one").start();
        new Thread(demoTest,"two").start();
        new Thread(demoTest,"three").start();

    }
}

六.发现问题,提出synchronized的概念和用途

但在现实情况,人抢鞋是有延迟的,你不可能像程序一样一秒钟不到就抢完了,所以有使用sleep()方法。

package com.thread;

public class DemoTest implements Runnable{

    public int nike = 10;
   @Override
    public void run() {
       while (true) {
           try {
               // 设置延迟为500毫秒,等于半秒种
               Thread.sleep(500);
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
           if (nike >0 ) {
               System.out.println(Thread.currentThread().getName() +"还剩"+(--nike)+"双鞋");
           }
       }
    }
}
package com.thread;

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

        DemoTest demoTest = new DemoTest();


        new Thread(demoTest,"one").start();
        new Thread(demoTest,"two").start();
        new Thread(demoTest,"three").start();

    }
}

?

可以从运行结果看出,one和two都抢到第六双鞋,three抢到第零双鞋。

出现这样的原因,是因为线程不同步,线程不安全。可以使用synchronized锁对象,同步数据。

package com.thread;

public class DemoTest implements Runnable{

    public int nike = 10;

    // 创建synchronized锁对象
    Object lock = new Object();

   @Override
    public void run() {
       while (true) {
           // 同步数据,同步代码块
           synchronized (lock) {
               try {
                   // 设置延迟为500毫秒,等于半秒种
                   Thread.sleep(500);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               if (nike > 0) {
                   System.out.println(Thread.currentThread().getName() + "还剩" + (--nike) + "双鞋");
               }
           }
       }
    }
}

synchronized锁的原理:

如何理解锁呢?当用户一抢到第一双鞋时,锁住第一双鞋,其它用户就无法抢了上面的synchronized锁的使用方法为同步代码块,还有一种为同步方法(推荐使用)。

package com.thread;

public class DemoTest implements Runnable{

    public int nike = 10;

    // 创建synchronized锁对象
    Object lock = new Object();

   @Override
    public void run() {
       while (true) {
           nikeCatch();
       }
    }
    
    // 同步方法,推荐使用,清晰可观
    public synchronized void nikeCatch() {
       
            try {
                // 设置延迟为500毫秒,等于半秒种
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }      
            if (nike > 0) {
                System.out.println(Thread.currentThread().getName() + "还剩" + (--nike) + "双鞋");
            }
    }
    
}

七.Lock、ReentrantLock同步锁?

相比synchronized锁,其实还有更好的锁,名为同步锁。

package com.thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DemoTest implements Runnable{
    public int nike = 10;

    // 创建同步锁,Lock是一个接口,所以要使用它的实现类
   Lock reentrantLock = new ReentrantLock();

   @Override
    public void run() {
       while (true) {
           // 上锁
           reentrantLock.lock();

               try {
                   if (nike > 0) {
                       // 设置延迟为500毫秒,等于半秒种
                       Thread.sleep(500);
                       System.out.println(Thread.currentThread().getName() + "还剩" + (--nike) + "双鞋");
                   }
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               } finally {
                   // 解锁
                   reentrantLock.unlock();
               }
           }
   }
}

?

比较synchronized与reentrantLock区别

  • JDK1.5中,synchroized是重量级操作,性能低效,Lock性能高,更稳定
  • JDK1.6中,synchroized加入很多优化,更加稳定了

锁的释放

  • synchronized以获取锁的线程执行完同步代码,如果线程执行发生异常,jvm会让线程释放锁
  • Lock在finally中必须释放锁,不然容易造成线程死锁

死锁产生

  • synchronized在发生异常时候会自动释放占有的锁,不会出现死锁
  • Lock发生异常时候,不会主动释放,必须手动unlock来释放锁,可能引起死锁的发生

用法

  • synchronized在需要同步的对象中加入,可以加在方法上,也可以加在特定代码块中,括号中表示需要锁的对象
  • Lock一般使用ReentrantLock类做为锁,通过lock()加锁和unlock()解锁指出,在finally中写unlock()防止死锁
    ?

八.Thread API说明

?Thread (Java Platform SE 7 ) (oracle.com)

九.CPU线程调度、Priority线程优先级、优先级常量、剩余小问题?

CPU线程调度

  • 每一个线程的优先使用权都是系统随机分配的,人人平等,谁先分配到谁先用
  • 可以设置优先级赋予某一个线程拥有至高适用权,最高为10,最低为1,默认为5,Java可以抢占CPU

线程1-10中,main()主线程的value = 5,创建?MaxPriorityThread?类和MinPriorityThread来查看线程执行顺序?

package com.thread;

public class MaxPriorityThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}
package com.thread;

public class MinPriorityThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}
package com.thread;

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

        Thread maxThread = new Thread(new MaxPriorityThread(),"max");
        Thread minThread = new Thread(new MinPriorityThread(),"min");

        // 使用setPriority()方法即可越权
        maxThread.setPriority(Thread.MAX_PRIORITY);
        minThread.setPriority(Thread.MIN_PRIORITY);
        
        maxThread.start();
        minThread.start();
    }
}

?

我上面的结果是对的,但是有些系统的结果跟我不一样。原因是你的CPU调度程序非常快,程序还没有反应过来程序就结束了。

十.?join线程插队?

上面的CPU调度,如果你把main加进去,你会发现无论main在哪里都会优先调度。?

package com.thread;

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

        Thread maxThread = new Thread(new MaxPriorityThread(),"max");
        Thread minThread = new Thread(new MinPriorityThread(),"min");

        // 使用setPriority()方法即可越权
        maxThread.setPriority(Thread.MAX_PRIORITY);
        minThread.setPriority(Thread.MIN_PRIORITY);

        maxThread.start();
        minThread.start();

        for (int i = 1; i < 8; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

但是我们可以使用join()方法,进行插队。

package com.thread;

public class Mani {
    public static void main(String[] args) throws InterruptedException{

        Thread maxThread = new Thread(new MaxPriorityThread(),"max");
        Thread minThread = new Thread(new MinPriorityThread(),"min");

        // 使用setPriority()方法即可越权
        maxThread.setPriority(Thread.MAX_PRIORITY);
        minThread.setPriority(Thread.MIN_PRIORITY);

        maxThread.start();
        minThread.start();

        for (int i = 1; i < 8; i++) {
            System.out.println(Thread.currentThread().getName());
            if (i == 3) {
                // 使用时,需要抛出异常InterruptedException
                maxThread.join();
            }
        }
    }
}


?

十一.sleep线程休眠

?在上面抢鞋的案例中,说到过。

package com.thread;

public class Mani {
    public static void main(String[] args) throws InterruptedException {

        Thread maxThread = new Thread(new MaxPriorityThread(),"max");
        Thread minThread = new Thread(new MinPriorityThread(),"min");

        // 使用setPriority()方法即可越权
        maxThread.setPriority(Thread.MAX_PRIORITY);
        minThread.setPriority(Thread.MIN_PRIORITY);

            // 需要抛出异常或捕获异常
            maxThread.sleep(1000);
            maxThread.start();
            minThread.start();

        }
    }

十二.yield线程让步?

package com.thread;

public class YieldTest implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName());
            // 每被5整除就让步
            if (i % 5 == 0) {
                System.out.println(Thread.currentThread().getName()+"------让步");
                // 让步使用方法:yield()
                Thread.yield();
            }
        }
    }
}
package com.thread;

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

        Thread yieldOne = new Thread(new YieldTest(),"one");
        Thread yieldTwo = new Thread(new YieldTest(),"two");

        yieldOne.start();
        yieldTwo.start();
    }
}

.yield()方法可以实现线程让步,让其它线程执行,one输出一次的时候给two让步了,有时程序运行的太快了,以至于还没打印出让步输出,two已经输出完毕了?

十三. 线程状态还是斗地主吧

?

Java中线程的状态分为6种–以斗地主为例

1.新建(NEW)-新建一局游戏

2.可运行(RUNNABLE)-初始状态是可运行的

3.阻塞(BLOCKED)-谁出牌谁获得一个锁,导致阻塞,出好牌则疏通阻塞

4.等待(WAITING)-不出牌的等待通知

5.计时等待(TIMED_WAITING)-出牌时,其他人计时等待超时或通知

6.终止(TERMINATED)-游戏结束
?

十四.?发现实际问题,抛出线程通信的含义?

线程优先级

  • Win11务管理器中,线程有6个优先级设置
  • 线程的调度目的就是通知另一个线程去执行

?线程通信

线程通信就如斗地主一名玩家出完牌,要通知其他两位玩家出了什么牌。?

十五.线程的通信:wait和notify

线程通信有两种状态等待(wait)和唤醒(notify),我们接下来以nike生产者与消费者为例子;

产品:nike

生产者:Producer

消费者:Customer?

package com.thread;

public class Nike {
    // 判断nike是否有库存
    public boolean isStatus = false;
}
package com.thread;

public class Producer extends Thread{


    // 设置synchronized锁类型为Nice
    private Nike nike;

    public Producer(Nike nike) {
        this.nike = nike;
    }

    @Override
    public void run() {
       while (true) {
           // synchronized锁为nike,以产品nike同步
           synchronized (nike) {
               // nike没有库存了,打电话给生产者,消费者等待。
               if (nike.isStatus == false) {
                   try {
                       // 消费者等待使用:wait()方法
                       nike.wait();
                   } catch (InterruptedException e) {
                       throw new RuntimeException(e);
                   }
               }
               // nike买完了
               nike.isStatus = false;

               // 唤醒其他线程,唤醒生产者
               System.out.println(Thread.currentThread().getName()+"赶紧生产");

               // 唤醒生产者使用:notify()方法
               nike.notify();
           }
       }
    }
}
package com.thread;

public class Customer extends Thread{

    private Nike nike;

    // 设置synchronized锁类型为Nice
    public Customer(Nike nike) {
        this.nike = nike;
    }

    @Override
    public void run() {
        while (true) {
            // synchronized锁为nike,以产品nike同步
            synchronized (nike) {
                // 库存充足,生产者等待
                if (nike.isStatus == true) {
                    try {
                        // 生产者等待使用:wait()方法
                        nike.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
                // nike生产好了
                nike.isStatus = true;

                // 唤醒其他线程,唤醒消费者
                System.out.println(Thread.currentThread().getName()+"赶紧购买");

                // 唤醒消费者使用:notify()方法
                nike.notify();
            }
        }
    }
}
package com.thread;

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

     Nike nike = new Nike();
     new Producer(nike).start();
     new Customer(nike).start();

    }
}

十六.notifyAll?

如果你有多个生产者或消费者要唤醒,那就使用notifyAll()方法?

               // nike买完了
               nike.isStatus = false;

               // 唤醒其他线程,唤醒生产者
               System.out.println(Thread.currentThread().getName()+"赶紧生产");

               // 唤醒全部的生产者使用:notifyAll()方法
               nike.notifyAll();
                // nike生产好了
                nike.isStatus = true;

                // 唤醒其他线程,唤醒消费者
                System.out.println(Thread.currentThread().getName()+"赶紧购买");

                // 唤醒全部的消费者使用:notifyAll()方法
                nike.notifyAll();

十七.提及Process进程

我们上面讲的都是线程,而进程可以看以下的文档简单了解

ProcessBuilder (Java Platform SE 7 ) (oracle.com)

文章来源:https://blog.csdn.net/2301_76556912/article/details/135035525
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。