复习（基础1）：多线程

最新推荐文章于 2024-02-06 15:44:19 发布
最新推荐文章于 2024-02-06 15:44:19 发布
阅读量144 收藏 1
点赞数 1
文章标签： jvm java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46061535/article/details/126812654
版权

1.多线程的创建

（1）继承Thread类

public class MyThread extends Thread{
    @Override
    public void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行次数："+i);
        }
    }
}

 

/*
多线程的创建方式1：继承Thead类的实现
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //new一个新线程对象
        Thread t = new MyThread();
        //调用start方法启动线程（执行的还是run方法）
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出："+i);
        }

    }
}

 

 

 

（2）实现Runnable接口

public class MyThreadDemo2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出："+i);
        }
    }
}

 

    public static void main(String[] args) {
        //创建任务对象
        Runnable runnable = new MyThreadDemo2();
        //把任务对象交给Thread处理
        Thread t = new Thread(runnable);
        //启动线程
        t.start();
    }

 

（3）JDK5.0提供了Callable和FutrueTask来实现

 

 

public class MyThreadDemo3 implements Callable<String> {
    private int n;
    public MyThreadDemo3(int n){
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= n ; i++) {
            sum += i;
        }
        return "子线程执行的结果是："+sum;
    }
}
public class ThreadDemo3 {
    public static void main(String[] args){
        Callable<String> call = new MyThreadDemo3(100);

        FutureTask<String> futureTask = new FutureTask<>(call);

        Thread t = new Thread(futureTask);

        t.start();
        

        try {
            String s1 = futureTask.get();
            System.out.println(s1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 三种方法对比

2.Thread类的常用方法

 

 

 

3.线程安全

package com.itwpf.d3_thread_safe;

public class ThreadDemo {
    public static void main(String[] args) {
        Account account = new Account("id_card_01",10000);
        new DrawThread(account,"小红").start();
        new DrawThread(account,"小明").start();


    }
}


package com.itwpf.d3_thread_safe;

public class Account {
    private String id;
    private double money;

    public Account() {
    }

    public Account(String id, double money) {
        this.id = id;
        this.money = money;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id='" + id + '\'' +
                ", money=" + money +
                '}';
    }

    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        if(this.money>=money){
            System.out.println(name+"来取钱，吐出"+money);
            this.money -= money;
            System.out.println("最后剩余："+this.money);
        }else{
            System.out.println("余额不足");
        }
    }
}



package com.itwpf.d3_thread_safe;

public class DrawThread extends Thread{

    private Account acc;
    public DrawThread(Account acc){
        this.acc = acc;
    }

    public DrawThread(Account acc, String name) {
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        acc.drawMoney(10000);
    }
}

 

4.线程同步

 

（1）加锁方式1：同步代码块

 

    //在类Account的核心方法drawMony中加锁

    public void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        synchronized(this){
            if(this.money>=money){
                System.out.println(name+"来取钱，吐出"+money);
                this.money -= money;
                System.out.println("最后剩余："+this.money);
            }else{
                System.out.println("余额不足");
            }

        }

    }

 

（2）加锁方式2：同步方法

 

 

    public synchronized void drawMoney(double money) {
        String name = Thread.currentThread().getName();
        if(this.money>=money){
            System.out.println(name+"来取钱，吐出"+money);
            this.money -= money;
            System.out.println("最后剩余："+this.money);
        }else{
            System.out.println("余额不足");
        }
    }

（3）加锁方式3：Lock锁

 

public void drawMoney(double money) {
        String name = Thread.currentThread().getName();

        lock.lock();//上锁
        try{
            if(this.money>=money){
                System.out.println(name+"来取钱，吐出"+money);
                this.money -= money;
                System.out.println("最后剩余："+this.money);
            }else{
                System.out.println("余额不足");
            }
        }finally {
            lock.unlock();//解锁
        }
    }

5.线程通信

 

package com.itheima.d7_thread_comunication;

/**
   呼叫系统。
 */
public class CallSystem {
    // 定义一个变量记录当前呼入进来的电话。
    public static int number = 0; // 最多只接听一个。

    /* 接入电话
     */
    public synchronized static void call() {
        try {
            number++;
            System.out.println("成功接入一个用户，等待分发~~~~");

            // 唤醒别人 : 1个
            CallSystem.class.notify();
            // 让当前线程对象进入等待状态。
            CallSystem.class.wait();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
       分发电话
     */
    public synchronized static void receive() {
        try {
            String name = Thread.currentThread().getName();
            if(number == 1){
                System.out.println(name + "此电话已经分发给客服并接听完毕了~~~~~");
                number--;
                // 唤醒别人 : 1个
                CallSystem.class.notify();
                CallSystem.class.wait(); // 让当前线程等待
            }else {
                // 唤醒别人 : 1个
                CallSystem.class.notify();
                CallSystem.class.wait(); // 让当前线程等待
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.itheima.d7_thread_comunication;

public class CallThread extends Thread{
    @Override
    public void run() {
        // 不断的打入电话
        while (true){
            CallSystem.call();
        }
    }
}

package com.itheima.d7_thread_comunication;

/**
   接电话线程类
 */
public class ReceiveThread extends Thread{
    @Override
    public void run() {
        // 1号  2号
        while (true){
            CallSystem.receive();
        }
    }
}

package com.itheima.d7_thread_comunication;

public class TestDemo {
    public static void main(String[] args) {
        // 1、生产者线程：负责不断接收打进来的电话
        CallThread call = new CallThread();
        call.start();

        // 2、消费者线程：客服，每个客服每次接听一个电话
        ReceiveThread r1 = new ReceiveThread();
        r1.start();
    }
}

6.线程池

（1）概述

 

 

（2）常用API、参数说明

 

ExecutorService pool = new ThreadPoolExecutor(
                3,
                5,
                6,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy() );

 

 

（3）线程池处理Runnable任务

 

        ExecutorService pool = new ThreadPoolExecutor(
                3,
                5,
                6,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy() );

        pool.execute(new MyRunnable());


结果
pool-1-thread-1子线程0
pool-1-thread-1子线程1
pool-1-thread-1子线程2
pool-1-thread-1子线程3
pool-1-thread-1子线程4
本任务已休眠pool-1-thread-1

（4）线程池处理Callable任务

 

ExecutorService pool = new ThreadPoolExecutor(
                3,
                5,
                6,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy() );

        //pool.execute(new MyRunnable());

        Future<String> submit0 = pool.submit(new MyCallable(100));
        Future<String> submit1 = pool.submit(new MyCallable(5));
        Future<String> submit2 = pool.submit(new MyCallable(10));
        Future<String> submit3 = pool.submit(new MyCallable(20));
        Future<String> submit4 = pool.submit(new MyCallable(30));
        Future<String> submit5 = pool.submit(new MyCallable(40));
        Future<String> submit6 = pool.submit(new MyCallable(50));
        String rs = submit0.get();
        System.out.println(rs);
        System.out.println(submit1.get());
        System.out.println(submit2.get());
        System.out.println(submit3.get());
        System.out.println(submit4.get());
        System.out.println(submit5.get());
        System.out.println(submit6.get());


结果：
pool-1-thread-1线程返回的结果是：5050(执行1到100)
pool-1-thread-2线程返回的结果是：15(执行1到5)
pool-1-thread-3线程返回的结果是：55(执行1到10)
pool-1-thread-2线程返回的结果是：210(执行1到20)
pool-1-thread-1线程返回的结果是：465(执行1到30)
pool-1-thread-2线程返回的结果是：820(执行1到40)
pool-1-thread-1线程返回的结果是：1275(执行1到50)

（5）Executors工具类实现线程池

 

 

 

7.定时器

 

 

public class TimeDemo1 {
    public static void main(String[] args) {
        //创建定时器
        Timer timer  = new Timer();//定时器本身就是一个线程
        //调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行A  "+new Date());
            }
        },0,2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行B  "+new Date());
            }
        },0,2000);
    }
}

 

public class TimeDemo2 {
    public static void main(String[] args) {
        //创建ScheduledExecutorService线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        //开启定时器任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出AAA  "+new Date());
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出AAA  "+new Date());
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出bbb  "+new Date());
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出ccc  "+new Date());
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行输出ddd  "+new Date());
            }
        },0,2, TimeUnit.SECONDS);
    }
}

8.生命周期

 

 

 

wpf001学习
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
WPF多线程演示
12-31
WPF多线程演示
WPF多线程
LisenYang的专栏
01-14 1722
一、线程概述：【引用MSDN】  通常，WPF 应用程序从两个线程开始：一个用于处理呈现，一个用于管理 UI。呈现线程有效地隐藏在后台运行，而 UI 线程则接收输入、处理事件、绘制屏幕以及运行应用程序代码。大多数应用程序都使用一个 UI 线程，但在某些情况下，最好使用多个线程。我们将在后面举例说明这一点。 UI 线程对一个名为 Dispatcher 的对象内的工作项进行排队。Dispatc
C#多线程复习题目80道+答案
10-10
此资源有利于初学者巩固C#多线程的基础知识，内有80道练习题及答案。
Java实习生面试复习(五)：Thread线程学习
01-20
多线程也是面试中必问的点，是必备的基础技能。 Thread(线程)的概念 首先我们要知道线程的概念是什么，在继续往下说，大家可以先闭上眼回忆一下： 线程（Thread）是并发编程的基础，也是程序执行的最小单元，它依托...
429.427.JAVA基础教程_多线程-复习：线程的创建与常用方法(429).rar
11-09
429.427.JAVA基础教程_多线程-复习：线程的创建与常用方法(429).rar
计算机后端-Java-Java核心基础-第20章 多线程 03. 复习：线程的创建与常用方法.avi
05-22
计算机后端-Java-Java核心基础-第20章 多线程 03. 复习：线程的创建与常用方法.avi
计算机后端-Java-Java核心基础-第20章 多线程 02. 复习：IDEA使用与多线程基本概念.avi
05-22
计算机后端-Java-Java核心基础-第20章 多线程 02. 复习：IDEA使用与多线程基本概念.avi
WPF多线程实例
05-08
一个WPF多线程实例：两个列表listbox，每秒从第一个列表中随机抽取出一项，然后添加到第二个列表中，同时界面实现实时更新
wpf下多线程的例子
09-04
wpf下多线程的例子
c# WPF 多线程简单实例
06-02
c# WPF 多线程简单实例
wpf 多线程
不积跬步,无以至千里;不积小流,无以成江海
04-17 2581
一、线程概述：【引用MSDN】  通常，WPF 应用程序从两个线程开始：一个用于处理呈现，一个用于管理 UI。呈现线程有效地隐藏在后台运行，而 UI 线程则接收输入、处理事件、绘制屏幕以及运行应用程序代码。大多数应用程序都使用一个 UI 线程，但在某些情况下，最好使用多个线程。我们将在后面举例说明这一点。 UI 线程对一个名为 Dispatcher 的对象内的工作项进行排队。Dispa
WPF 多线程
c840136358的专栏
06-07 6261
在WPF应用中，如果遇到多线程的需求时，如果引用WPF控件时会引发异常，异常内容：调用线程无法访问此对象，因为另一个线程拥有该对象。具体如下： 调用代码： ThreadcountThread= new Thread( new ThreadStart(Count)); countThread.Start(); 在调用的Count方法引发如下　　在WPF应用中，如果遇到多线程的需求时，如果
【WPF】多线程Demo
cxyhjl的博客
03-16 321
程序框架主界面：主窗体xaml：<Grid Background="#FFDEDED4"> <TextBox x:Name="txtCountThreads" HorizontalAlignment="Left" Height="45" Margin="31,23,0,0" Text="7" TextWrapping="Wrap" VerticalAlignmen...
WPF 中的多线程编程模型
flysh05的专栏
05-12 598
WPF 调度器 DispatcherWPF 每个元素都有用一个Dispatcher属性，Dispatcher会自动在线程池中按优先级对工作项进行排队和调度。通过该属性执行指定的委托，即可实现不同线程之间的交互，而不出现死锁问题。中常用的方法：Invoke(), InvokeAsync( )TextBox1.Dispatcher.Invoke( ...)TextBox1.Dispatcher.InvokeAsync( ...)Invoke( ) 方法是同步调用，即直到在线程池中实际执行完该委托它才返回。Inv
WPF中使用多线程技术（1）
最新发布
weixin_42776892的博客
02-06 953
2个线程的工作，我们希望一个文本是每1秒改变一次文本内容，另一个文本程序是每6秒改变一次文本内容其中的延时函数是Thread.Sleep(TimeSpan.FromSeconds(x));形参里第2个是指向一个委托方法其 (ThreadStart)是一个我暂且理解是个线程类中的委托类型，用这个类型强制化一个委托方法,delegate ()就理解为是委托方法，这个方法里面承载的内容{} 在这个花括号里才能操控改变控件属性的值，入程序上描述的那样，同样也可以调用其他方法函数来执行这个过程。
WPF_21_多线程
jqwang_2009的专栏
02-10 1167
多线程编程可使WPF应用程序执行后台工作，同时保持用户界面能够进行响应。
Java复习题1.pdf
02-28
首先，关于多线程部分，代码展示了如何创建并启动两个子线程。`MyThread`类继承自`Thread`，这意味着`thread1`和`thread2`实例实际上都是线程对象。在`main`方法中，`thread1`通过`start()`方法启动，而`thread2`则...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值