Java多线程

最新推荐文章于 2024-08-18 23:26:05 发布

小母牛吹泡泡

最新推荐文章于 2024-08-18 23:26:05 发布

阅读量554

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_61857489/article/details/124602350

版权

本文详细介绍了Java多线程的各个方面，包括线程的概念、创建线程的三种方式（Thread类、Runnable接口、Callable接口）、线程状态、线程同步机制（如synchronized和Lock），以及线程协作和线程池的使用。通过实例代码展示了如何实现线程的创建、控制和通信，强调了多线程在提升程序性能和解决并发问题中的重要性。

摘要由CSDN通过智能技术生成

学习目标：

*）了解线程与进程的区别
*）掌握创建多线程的两种方式
*）了解线程的生命周期及状态转换
*）掌握线程调度
*）掌握多线程的同步

概述

多线程是提升程序性能非常重要的一种方式，也是学习Java编程必须要掌握的技术。使用多线程可以让程序充分利用CPU的资源，提高CPU的使用效率，从而解决高并发带来的负载均衡问题，
线程概述：
计算机能够同时完成多项任务，例如：一边访问浏览器，一边使用QQ聊天，这就是多线程技术，计算机的中央处理器（Central Processing Unit ，CPU）即使是单核也可以同时运行多个任务，因为操作系统执行多个任务时就是让CPU对多个任务进行轮流交替运行。java时支持多线程的语言之一，它对多线程编程提供了内置支持，可以使程序执行多个执行片段。。
进程：Process
在学习线程之前，需要先了解什么是进程。在一个操作系统中，每个独立的程序都可以称为一个进程，也就是“正在运行的程序”。在多任务操作系统中，表面上是支持进程并发执行，例如一边听音乐一边聊天。但是实际上进程并不是同时运行的。在计算机中，所有的应用程序都是由CPU执行的，对于CPU而言，在某个时间点只能运行一个程序，也就是说只能运行一个进程。操作系统会为每个进程分配一段有限的CPU使用时间，CPU在这段时间执行某个进程，然后在下一段时间执行另一个进程。由于CPU运行速度很快，能在极短的时间内不同的进程之间进行切换，所有给人同时执行多个程序的感觉。
例如：在现实生活中有太多同时做多件事情的例子。看起来多任务都在做，但是其本质还是在同一时间我们的大脑只做了一件事。
多线程：Thread
每个运行的程序都是一个进程，在进程中还可以有多个执行单元同时运行，之前学习的章节中代码都是依次往下执行的，没有出现两段代码交替执行，这样的程序称作为单线程程序。如果想要程序实现多段代码交替运行的效果，则需要创建多个线程，既多线程。多线程是指一个进程在执行的过程中产生的多个单线程，这些单线程程序运行时是相互独立的，它们可以并发执行。多线程看似是同时执行的其实于进程是一样的，也是由CPU轮流执行的，CPU很快，故而给人一种同时运行的感觉

线程创建：

Thread class（继承Thread类：重点）
Runnable接口（实现Runnable接口：重点）
Callable接口（实现Callable接口：了解）

Thread类演示：
创建线程方法一：由一个类继承Thread类然后重写run（）方法，在调用这个线程时要先创建整继承类的对象然后调用start（）方法开启线程

package TestThread;

/**
 * 创建线程方法一：
 * 继承Thread类，重写run（）方法，调用start（）方法开启线程
 */
public class Demo01 extends Thread{
   
    @Override
    public void run() {
   
        //run方法线程体
        for (int i = 0; i < 20; i++) {
   
            System.out.println("我在学习---"+i);
        }
    }
    //main线程。主线程
    public static void main(String[]args){
   
        //创建一个线程对象
        Demo01 d = new Demo01();
        //调用start方法开启线程
        d.start();


        for (int i = 0; i < 2000; i++) {
   
            System.out.println("我在学习多线程---"+i);
        }
    }
    //总结：注意，线程开启不一定立即执行，有CPU调度执行
}

运行结果：我们可以看到创建的线程运行结果时穿插在主线程内的
这说明了：线程开启不一定立即执行，有CPU调度执行
在这里插入图片描述
实现Runnable接口：
定义MyRunnable类实现Runnable接口；
实现run（）方法，编写线程体。
创建线程对象，使用start（）方法启动线程

package TestThread;

/**
 * 使用Runnable接口创建线程
 * 1.实现Runnable接口
 * 2.重写run（）方法
 * 3.执行线程需要丢人runnable接口实现类，调用start（）方法
 */
public class Demo03 implements Runnable{
   
    @Override
    public void run() {
   
        //run方法线程体
        for (int i = 0; i < 20; i++) {
   
            System.out.println("我在学习---"+i);
        }
    }
    //main线程。主线程
    public static void main(String[]args){
   
        //创建Runnable接口实现类对象
        Demo03 d = new Demo03();
        //创建线程对象，通过线程对象开启我们的线程，代理
//        Thread thread = new Thread(d);
//        thread.start();
        new Thread(d).start();

        for (int i = 0; i < 1000; i++) {
   
            System.out.println("我在学习多线程---"+i);
        }
    }
}

运行结果：在这里插入图片描述
小结：
继承Thread类：
子类继承Thread类具备多线程能力。
启动线程：子类对象.start()
不建议使用：避免Java单继承局限性。
实现Runnable的接口：
实现Runnable接口具备多线程能力。
启动线程：new Thread(传入目标对像）.start();
推荐使用，避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。
例如：

package TestThread;

/**
 * 多个线程操作同一个对象
 * 卖火车票的例子
 */
public class Demo04 implements Runnable{
   

    //1.定义票数
    private int ticketNums =10;
    //2重写run（）方法
    @Override
    public void run() {
   
        //写个死循环
        while(true){
   
            if (ticketNums<=0){
   //跳出死循环的条件
                break;
            }
            //模拟延时,然后捕捉一下异常
            try {
   
                Thread.sleep(200);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            //Thread.currentThread().getName()返回Thread对象的名字
            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }
    //3.创建主线程
    public static void main(String[]args){
   
        //3.1创建自定义线程对象
        Demo04 demo04 = new Demo04();
        //3.2创建Thread对象传入自定义线程对象，然后定义一个名字
        new Thread(demo04,"小张").start();
        new Thread(demo04,"小六").start();
        new Thread(demo04,"小七").start();
    }
}

运行结果：在这里插入图片描述
总结一下：多个线程操控同一个资源下，线程不安全，数据紊乱。
Callable接口：
1.实现Callable接口，需要返回值类型。
2.重写call方法，需要抛出异常。
3.创建目标对象
4.创建执行服务:ExecutorService ser = Executors.new FixedThreadPool(1);
5.提交执行：Future< Boolean> result1 = ser.submit(t1);
6.获取结果：Boolean r1 = resuit1.get（）；
7.关闭服务：ser.shutdownNow();
代码演示：

package TestThread;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

/**
 * Callable线程接口使用
 */
public class Demo05 implements Callable<Boolean> {
   
    private String url;
    private String name;

    public Demo05(String url, String name){
   
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() {
   
        WebDownloader2 wd = new WebDownloader2();
        wd.downloader(url,name);
        System.out.println("下载了文件名为："+name);
        return true;
    }
    //主路经
    public static void main(String[]args) throws ExecutionException, InterruptedException {
   
        Demo05 t1 =new Demo05("https://upload-images.jianshu.io/upload_images/25016246-59a89b9ed48cf48a.png","d:\\aaa\\1.png");
        Demo05 t2 =new Demo05("https://upload-images.jianshu.io/upload_images/25016246-6e85ab67995519c7.png","d:\\aaa\\2.png");
        Demo05 t3 =new Demo05("https://upload-images.jianshu.io/upload_images/25016246-59a89b9ed48cf48a.png","d:\\aaa\\3.png");

        //创建执行服务:
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行：
        Future< Boolean> r1 = ser.submit(t1);
        Future< Boolean> r2 = ser.submit(t2);
        Future< Boolean> r3 = ser.submit(t3);
        //获取结果：
        Boolean rs1 = r1.get();
        Boolean rs2 = r2.get();
        Boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务：
        ser.shutdownNow();
    }
}
//下载器
class WebDownloader2{
   
    //下载方法
    public void downloader(String url,String name){
   
        try {
   
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
   
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

运行结果：在这里插入图片描述
Lambda表达式：
希腊字母表中的第十一个字母，英文名称：Lambda。
避免匿名类定义过多。
其实本质属于函数式编程概念。
（params)->expression[表达式]
(params)->statement[语句]
(params)->{statements}
.)理解Functional Interface（函数式接口）是学习Java8 Lambda表达式的关键所在。
函数式接口的定义：
任何接口只包含一个抽象方法，那么这个接口就式函数式接口。
对于函数式接口，我们可以创建Lambda表达式创建对象。
例如Runnable接口就是函数式接口：
public Interface Runnable{
public abstract void run();
}

package TestThread;

/**
 * 推导lambda表达式
 */

最低0.47元/天解锁文章

小母牛吹泡泡

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫