首页 > 其他分享 >【博学谷学习记录】超强总结,用心分享 。多线程相关点知识学习。

【博学谷学习记录】超强总结,用心分享 。多线程相关点知识学习。

时间:2022-10-09 18:44:27浏览次数:60  
标签:run Thread void 学习 线程 超强 new 多线程 public

一、实现多线程

  1.1了解多线程

    多线程是指从软件或硬件上实现多个线程并发执行的技术。具有多线程 能力的计算机因有硬件支持而能够在同一时间执行多个线程,提升性能。

  1.2并发和并行

    并行:在同一时刻,有多个指令在多个CPU上同时运行。(多个cpu一同运行)

    并发:在同一时刻,有多个指令在单个CPU上交替运行。 (单个cpu上运行多个指令)

  1.3进程和线程

    进程:是正在运行的程序,具有独立性、动态性和并发性

    线程:是进程中的单个顺序控制流,是一条执行路径

  1.4实现多线程方式一:继承Tread类

    方法介绍

      

方法名说明
void run() 在线程开启后,此方法将被调用执行
void start() 使此线程开始执行,Java虚拟机会调用run方法()

    实现步骤

      1)定义一个类MyThead继承Thread类

      2)在MyThread类中重写run()方法

      3)创建MyThread类的对象

      4)启动线程

    

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

//        my1.run();
//        my2.run();

        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
    }
}

    问题:1)为什么要重写run()方法?

          因为run()是用来封装被线程执行的代码

        2)run()方法和start()方法的区别

          run():封装线程执行的代码,直接调用,相当于普通方法的调用

          start():启动线程,然后由JVM调用此线程的run()方法

    1.5实现多线程方式二:实现Runnable接口

      Thread构造方法

    

方法名说明
Thread(Runnable target) 分配一个新的Thread对象
Thread(Runnable target, String name) 分配一个新的Thread对象

     实现步骤

      定义一个类MyRunnable实现Runnable接口

      在MyRunnable类中重写run()方法

      创建Thread类的对象,把MyRunnable对象作为构造方法的参数

      启动线程    

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
        //创建Thread类的对象,把MyRunnable对象作为构造方法的参数
        Thread t1 = new Thread(my,"坦克");
        Thread t2 = new Thread(my,"飞机");
        //启动线程
        t1.start();
        t2.start();
    }
}

    1.6实现多线程方式三:实现Callable接口

    方法介绍:

方法名说明
V call() 计算结果,如果无法计算结果,则抛出一个异常
FutureTask(Callable<V> callable) 创建一个 FutureTask,一旦运行就执行给定的 Callable
V get() 如有必要,等待计算完成,然后获取其结果

  实现步骤:

    定义一个类MyCallable实现Callable接口

    在MyCallable类中重写call()方法

    创建MyCallable类的对象

    创建Future的实现类FutureTask对象,把MyCallable对象作为构造方法的参数

    创建Thread类的对象,把FutureTask对象作为构造方法的参数

    启动线程

    在调用get方法,就可以获取线程结束后的结果

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩表白" + i);
        }
        //返回值就表示线程运行完毕之后的结果
        return "答应";
    }
}
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程开启之后需要执行里面的call方法
        MyCallable mc = new MyCallable();

        //Thread t1 = new Thread(mc);

        //可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mc);

        //创建线程对象
        Thread t1 = new Thread(ft);

        String s = ft.get();
        //开启线程
        t1.start();

        //String s = ft.get();
        System.out.println(s);
    }
}

    三种实现方式的对比:

      实现Runnable、Callable接口:

        好处:扩展性强、实现该接口的同时还可以继承其他类

        缺点:编程相对复杂、不能直接使用Thread类中的方法

      继承Thread类:

        好处:编程比较简单,可以直接使用Thread类中的方法

        缺点:扩展性较差,不能再继承其他的类

    1.7设置和获取线程名称

    方法介绍

      

方法名说明
void setName(String name) 将此线程的名称更改为等于参数name
String getName() 返回此线程的名称
Thread currentThread() 返回对当前正在执行的线程对象的引用

     

public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

        //void setName(String name):将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");

        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");

        my1.start();
        my2.start();

        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

    1.8线程休眠

      

方法名说明
static void sleep(long millis) 使当前正在执行的线程停留(暂停执行)指定的毫秒数

      

 

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}
public class Demo {
    public static void main(String[] args) throws InterruptedException {
        /*System.out.println("睡觉前");
        Thread.sleep(3000);
        System.out.println("睡醒了");*/

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

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

      1.9线程优先级

        两种调度方式:

          分时调度模型:所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片

          抢占式调度模型:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取CPU时间片相对多一些

        Java使用的是抢占式调度模型

        随机性

        相关方法:

方法名说明
final int getPriority() 返回此线程的优先级
final void setPriority(int newPriority) 更改此线程的优先级线程默认优先级是5;线程优先级的范围是:1-10

    

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
        return "线程执行完毕了";
    }
}
public class Demo {
    public static void main(String[] args) {
        //优先级: 1 - 10 默认值:5
        MyCallable mc = new MyCallable();

        FutureTask<String> ft = new FutureTask<>(mc);

        Thread t1 = new Thread(ft);
        t1.setName("飞机");
        t1.setPriority(10);
        //System.out.println(t1.getPriority());//5
        t1.start();

        MyCallable mc2 = new MyCallable();

        FutureTask<String> ft2 = new FutureTask<>(mc2);

        Thread t2 = new Thread(ft2);
        t2.setName("坦克");
        t2.setPriority(1);
        //System.out.println(t2.getPriority());//5
        t2.start();
    }
}

二、线程同步

  

2.1卖票【应用】

  • 案例需求

    某电影院目前正在上映国产大片,共有100张票,而它有3个窗口卖票,请设计一个程序模拟该电影院卖票

  • 实现步骤

    • 定义一个类SellTicket实现Runnable接口,里面定义一个成员变量:private int tickets = 100;

    • 在SellTicket类中重写run()方法实现卖票,代码步骤如下

    • 判断票数大于0,就卖票,并告知是哪个窗口卖的

    • 卖了票之后,总票数要减1

    • 票卖没了,线程停止

    • 定义一个测试类SellTicketDemo,里面有main方法,代码步骤如下

    • 创建SellTicket类的对象

    • 创建三个Thread类的对象,把SellTicket对象作为构造方法的参数,并给出对应的窗口名称

    • 启动线程

    

public class SellTicket implements Runnable {
    private int tickets = 100;
    //在SellTicket类中重写run()方法实现卖票,代码步骤如下
    @Override
    public void run() {
        while (true) {
            if(ticket <= 0){
                    //卖完了
                    break;
                }else{
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
                }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建SellTicket类的对象
        SellTicket st = new SellTicket();

        //创建三个Thread类的对象,把SellTicket对象作为构造方法的参数,并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");

        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

    问题:相同的票出现了多次和出现了负数的票

    产生原因:线程执行的随机性导致的,可能在卖票过程中丢失CPU的执行权,导致出现问题

      2.2同步代码块解决数据安全问题

        安全问题出现的条件

          多线程环境

          有共享数据

          有多条语句操作共享数据

        如何解决多线程安全问题?

          基本思路:让程序没有安全问题的环境

        如何实现:

          把多条语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可  

          Java提供了同步代码块的方式来解决

        同步代码块格式:

          synchronized(任意对象) { 

          多条语句操作共享数据的代码
              } 

        synchronized(任意对象):就相当于给代码加锁了,任意对象就可以看成是一把锁

        同步的好处和弊端

        • 好处:解决了多线程的数据安全问题

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

   

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
                //t1进来后,就会把这段代码给锁起来
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                        //t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--; //tickets = 99;
                }
            }
            //t1出来了,这段代码的锁就被释放了
        }
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

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

      2.3同步方法解决数据安全问题【应用】

      •     同步方法的格式

        同步方法:就是把synchronized关键字加到方法上

        修饰符 synchronized 返回值类型 方法名(方法参数) { 
        方法体;
        }

        同步方法的锁对象是什么呢?

        this

          •     静态同步方法

            同步静态方法:就是把synchronized关键字加到静态方法上

            修饰符 static synchronized 返回值类型 方法名(方法参数) { 
            方法体;
            }

            同步静态方法的锁对象是什么呢?

                类名.class

 

public class MyRunnable implements Runnable {
    private static int ticketCount = 100;

    @Override
    public void run() {
        while(true){
            if("窗口一".equals(Thread.currentThread().getName())){
                //同步方法
                boolean result = synchronizedMthod();
                if(result){
                    break;
                }
            }

            if("窗口二".equals(Thread.currentThread().getName())){
                //同步代码块
                synchronized (MyRunnable.class){
                    if(ticketCount == 0){
                       break;
                    }else{
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        ticketCount--;
                        System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
                    }
                }
            }

        }
    }

    private static synchronized boolean synchronizedMthod() {
        if(ticketCount == 0){
            return true;
        }else{
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketCount--;
            System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
            return false;
        }
    }
}

    2.5死锁

      线程死锁是指由于两个或者多个线程互相持有对象所需要的资源,导致这些线程处于等待状态,无法前往执行

      什么情况会产生死锁

        1.资源有限 2.同步嵌套

public class Demo {
    public static void main(String[] args) {
        Object objA = new Object();
        Object objB = new Object();

        new Thread(()->{
            while(true){
                synchronized (objA){
                    //线程一
                    synchronized (objB){
                        System.out.println("小康同学正在走路");
                    }
                }
            }
        }).start();

        new Thread(()->{
            while(true){
                synchronized (objB){
                    //线程二
                    synchronized (objA){
                        System.out.println("小薇同学正在走路");
                    }
                }
            }
        }).start();
    }
}

 

标签:run,Thread,void,学习,线程,超强,new,多线程,public
From: https://www.cnblogs.com/linwenguan/p/16773252.html

相关文章

  • 2022-2023-1 20221414《计算机基础和程序设计》第六周学习总结
    2022-2023-120221414《计算机基础和程序设计》第六周学习总结教材内容总结Polya解决问题:0.自顶而下1.理解问题(用提问来把问题搞明白)2.找到联系(寻找熟悉模型和把问......
  • 2022-2023-1 20221301 《计算机基础与程序设计》第六周学习总结
    2022-2023-120221301《计算机基础与程序设计》第六周学习总结作业信息这个作业属于哪个课程<班级的链接>https://edu.cnblogs.com/campus/besti/2022-2023-1-CFAP......
  • Java入门,如何高效学习
      对于当下要想入行学习Java,那就一定是个不错的选择,因为这个行业是个你只要努力就能看到成果的行业,而且就从近两年来看,当前的程序员依旧是这个时代的高薪职业,且想要入这......
  • 2022-2023-1 20221306《计算机基础与程序设计》第六周学习总结
    作业信息 班级链接:https://edu.cnblogs.com/campus/besti/2022-2023-1-CFAP作业要求:https://www.cnblogs.com/rocedu/p/9577842.html#WEEK06作业目标:《计算机科学概论》......
  • LINUX第三章学习笔记——Unix/Linux 进程管理
    第三章Unix/Linux进程管理多任务处理指的是同时进行几项独立活动的能力逻辑并行性称为“并发”多个CPU或处理器内核的多处理器系统中,可以在不同CPU上实时并发执......
  • unityshader学习笔记5
    Unity中的光照:光源光是由光源发射出来的,实时渲染中,通常把光源当成一个没有体积的点,用L来表示它的方向.在光学里,用辐照度来量化光.对于平行光来说,它的辐照度可通......
  • 01- Shell脚本学习--入门
    原文链接:https://github.com/52fhy/shell-book/blob/master/chapter1.md01-Shell脚本学习--入门标签:Shell[TOC]简介Shell是一种脚本语言,那么,就必须有解释器来执行......
  • 统计学习方法学习笔记-09-EM算法及其推广
    首先叙述EM算法,然后讨论EM算法的收敛性,作为EM算法的应用,介绍高斯混合模型的学习,最后介绍EM算法的推广-GEM算法EM算法的引入目的:概率模型有时候既含有观测变量,也含有隐变......
  • python多线程
    importtimeimportdatetimeimportthreadingdefdotask():whileTrue:print(datetime.datetime.now().strftime('%Y-%m-%d%H:%M:%S'))time.sleep(5)......
  • 【博学谷学习记录】超强总结,用心分享|MySql连接查询超详细总结
    一、概述在实际开发中,大部分情况下都不是在单表中进行数据操作,一般都是多张表进行联合查询。通常一个业务就会对应的有好几张表。MySql中的连接查询分为交叉连接,内连......