进 程 与 线 程

已于 2022-07-18 16:10:16 修改
阅读量162 收藏
点赞数
分类专栏： 多线程 文章标签： java
于 2022-07-18 15:55:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46423017/article/details/125839136
版权

进程与线程

  •  说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
  • 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
  • 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。
  • 线程是CPU调度和执行的的单位。

注意：

        很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，例如：服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

核心概念：

  1. 线程就是独立的执行路径;
  2. 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
  3. main()称之为主线程，为系统的入口，用于执行整个程序;
  4. 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。
  5. 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
  6. 线程会带来额外的开销，如cpu调度时间，并发控制开销。
  7. 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程的三种创建方式

（1）继承Thread类

  •    自定义线程类继承Thread类
  •    重写run()方法，编写线程执体
  •    创建线程对象，调用start()方法启动线程

    注：线程不一定立即执行，CPU安排调度

例子：

package com.threadanother.demo1;


//创建线程方式一：继承Thread类，重写run()方法，调用start开启线程
//总结：注意，线程开启不一定立即执行，由CPU调度执行
public class TestThread1 extends Thread{
    @Override
    public void run() {
        super.run();
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码----"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();

        //调用start()方法开启线程
        testThread1.start();

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

    }
}

输出结果：

 （2）实现Runable接口

  •   定义MyRunnable类实现Runnable接口
  •   实现run()方法，编写线程执行体
  •   创建线程对象，调用start()方法

注：推荐使用Runnable对象，因为Java单继承的局限性

例子：

package com.threadanother.demo1;


//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread3 implements Runnable{
    @Override
    public void run() {

        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("我在看代码----"+i);
        }
    }

    public static void main(String[] args) {
        //main线程，主线程

        //创建一个线程对象
        TestThread3 testThread3 = new TestThread3();

        //调用start()方法开启线程
        //创建线程对象，通过线程对象来开启我们的线程，代理
        //Thread thread = new Thread(testThread3);
        //thread.start();

        new Thread(testThread3).start();

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

    }
}

输出结果：

买车票

package com.threadanother.demo1;

//多个线程同时操作同一个对象
//买火车票的例子
//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据错乱
public class TestThread4 implements Runnable{

    //票数
    private int ticketNums = 10;

    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }

            //模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {
        TestThread4 ticket = new TestThread4();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();

    }
}

输出结果：

 扩展：
          模拟延时

//模拟延时
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

  注意：多个线程操作同一个资源时，线程不安全，会发生数据紊乱

龟兔赛跑

例子：

package com.threadanother.demo1;

public class Race implements Runnable {
    //胜利者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {

            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子")&& i%10==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);
            //如果比赛结束了，就停止程序
            if(flag){
                break;
            }


            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }

    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否胜利者
        if(winner != null){//已经存在胜利者了
            return true;
        }else{
            if(steps>=100){
                winner = Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
        return false;
        }

    public static void main(String[] args) {
        Race race = new Race();

        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();
    }

}

运行结果：

（3） 实现Callable接口（了解）

  • 实现Callable接口需要返回值类型
  • 重写call方法，需要抛出异常
  • 创建目标对象
  • 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
  • 提交执行：Future<Boolean>result1 = ser.submit(t1);
  • 获取结果：boolean r1 = result1.get()
  • 关闭服务：ser.shutdownNow();

例子：

package com.threadanother.demo1.demo2;

import com.threadanother.demo1.TestThread2;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


//线程创建方式三：实现callable接口
/*
callable的好处
1.可以定义返回值
2.可以抛出异常
 */
public class TestCalable implements Callable<Boolean> {

    private String url;     //网络图片地址
    private String name;   //保存的文件名

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

    //下载图片线程的执行体
    @Override
    public Boolean call() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件名为：" + name);
        return true;
    }

    public static void main(String[] args) {
        TestThread2 t1 = new TestThread2("https://image.baidu.com/search/index?ct=201326592&tn=baiduimage&word=%E5%9B%BE%E7%89%87&pn=0&spn=0&ie=utf-8&oe=utf-8&cl=2&lm=-1&fr=ala&se=&sme=&cs=2196812579%2C178847292&os=2981951213%2C133282478&objurl=https%3A%2F%2Fgimg2.baidu.com%2Fimage_search%2Fsrc%3Dhttp%3A%2F%2Fimg.jj20.com%2Fup%2Fallimg%2F4k%2Fs%2F02%2F2109242332225H9-0-lp.jpg%26refer%3Dhttp%3A%2F%2Fimg.jj20.com%26app%3D2002%26size%3Df9999%2C10000%26q%3Da80%26n%3D0%26g%3D0n%26fmt%3Dauto%3Fsec%3D1660653815%26t%3D005bb5404fd991753bb59669625b2c7e&di=7108135681917976577&tt=1&is=0%2C0&adpicid=0&gsm=1e&dyTabStr=MCwzLDEsNiw0LDIsNSw3LDgsOQ%3D%3D", "1.jpg");
        TestThread2 t2 = new TestThread2("https://image.baidu.com/search/index?ct=201326592&tn=baiduimage&word=%E5%9B%BE%E7%89%87&pn=0&spn=0&ie=utf-8&oe=utf-8&cl=2&lm=-1&fr=ala&se=&sme=&cs=2196812579%2C178847292&os=2981951213%2C133282478&objurl=https%3A%2F%2Fgimg2.baidu.com%2Fimage_search%2Fsrc%3Dhttp%3A%2F%2Fimg.jj20.com%2Fup%2Fallimg%2F4k%2Fs%2F02%2F2109242332225H9-0-lp.jpg%26refer%3Dhttp%3A%2F%2Fimg.jj20.com%26app%3D2002%26size%3Df9999%2C10000%26q%3Da80%26n%3D0%26g%3D0n%26fmt%3Dauto%3Fsec%3D1660653815%26t%3D005bb5404fd991753bb59669625b2c7e&di=7108135681917976577&tt=1&is=0%2C0&adpicid=0&gsm=1e&dyTabStr=MCwzLDEsNiw0LDIsNSw3LDgsOQ%3D%3D", "2.jpg");
        TestThread2 t3 = new TestThread2("https://image.baidu.com/search/index?ct=201326592&tn=baiduimage&word=%E5%9B%BE%E7%89%87&pn=0&spn=0&ie=utf-8&oe=utf-8&cl=2&lm=-1&fr=ala&se=&sme=&cs=2196812579%2C178847292&os=2981951213%2C133282478&objurl=https%3A%2F%2Fgimg2.baidu.com%2Fimage_search%2Fsrc%3Dhttp%3A%2F%2Fimg.jj20.com%2Fup%2Fallimg%2F4k%2Fs%2F02%2F2109242332225H9-0-lp.jpg%26refer%3Dhttp%3A%2F%2Fimg.jj20.com%26app%3D2002%26size%3Df9999%2C10000%26q%3Da80%26n%3D0%26g%3D0n%26fmt%3Dauto%3Fsec%3D1660653815%26t%3D005bb5404fd991753bb59669625b2c7e&di=7108135681917976577&tt=1&is=0%2C0&adpicid=0&gsm=1e&dyTabStr=MCwzLDEsNiw0LDIsNSw3LDgsOQ%3D%3D", "3.jpg");

//        //创建执行服务：
//        ExecutorService ser = Executors.newFixedThreadPool(3);
//
//        //提交执行
//        Future<Boolean> r1 = ser.submit(t1);
//        Future<Boolean> r2 = ser.submit(t1);
//        Future<Boolean> r3 = ser.submit(t1);
//
//        //获取结果
//        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 WebDownloader {
    //下载方法
    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方法出现问题");
        }
    }
}

优势：

  1. 可以定义返回值

  2. 可以抛出异常

小结

继承Thread类

  1. 子类继承Thread类具备多线程能力
  2. 启动线程：子类对象.start()
  3. 不建议使用：避免OOP单继承局限性

实现Runnable接口

  1. 实现接口Runnable具有多线程能力        
  2. 启动线程：传入对象 + Thread对象.start()
  3. 推荐使用：避免继承局限行，灵活方便，方便同一个对象被多个线程使用
siiove
关注
专栏目录
测试JAVA线程池核心数满了后什么时候开始创建新的线程
习惯了想你的博客
07-10 3822
文章目录环境测试代码输出结果 只要是Java面试，基本上线程池是没跑了。但是有个点总是卡在那里，不是很清楚，就是核心线程池数满了，没到最大线程数的时候。到底什么时候开始建线程呢，本文就从代码结果层面来测试一下。 首先，我们来创建了一个线程池，设置核心数5个，最大线程数10个，任务队列10个，alive时间是2s，每个任务就是随机的sleep一会，主要用来占用时间。 创建完线程后，每隔一秒钟，获取一下线程池的状态。 根据输出发现，当任务数大于5个后，active数依然没变，只要任务数为16个的时候，activ
android中UI主线程与子线程深入分析
09-03
在Android应用程序开发中，理解和掌握UI主线程与子线程的使用至关重要，因为它们直接影响到应用的性能和用户体验。UI主线程，也称为应用程序主线程或活动线程，是每个Android应用的核心部分，主要负责处理用户界面的...
Java中main方法启动的是一个进程还是一个线程
jiahanghacker的博客
05-28 9298
Java中main方法启动的是一个线程也是一个进程，一个java程序启动后它就是一个进程，进程相当于一个空盒，它只提供资源装载的空间，具体的调度并不是由进程来完成的，而是由线程来完成的。一个java程序从main开始之后，进程启动，为整个程序提供各种资源，而此时将启动一个线程，这个线程就是主线程，它将调度资源，进行具体的操作。Thread、Runnable的开启的线程是主线程下的子线...
main函数是主线程嘛？
weixin_61196167的博客
10-21 1326
一、什么是线程？ 线程是程序最基本的运行单位，而进程不能运行，所以能运行的，是进程中的线程。 二、线程是如何创建起来的？ 进程仅仅是一个容器，包含了线程运行中所需要的数据结构等信息。一个进程创建时，操作系统就会创建一个线程，这就是主线程，而其他的从线程，却要主线程的代码来创建，也就是程序员来创建。 当一个程序启动时，就有一个进程被操作系统创建，与此同时一个线程也立刻运行，该线程通常叫程序的主线程（Main Thread），因为它是程序开始时就执行的...
线程池核心线程、等待队列、非核心线程的创建时机
weixin_42934146的博客
09-18 3603
线程池核心线程、等待队列、非核心线程的创建时机 创建入下线程池，核心线程数为2，最大活动线程数为10，缓存队列长度为2。 private static ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 10, 1000L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2), new ThreadFactory() { @Override
玩转线程和进程
zzsj1990的博客
06-06 268
进程与线程相关知识点
C#子线程更新UI控件的方法实例总结
09-04
由于UI界面通常运行在主线程中，为保证用户界面的响应性和避免线程冲突，我们需要遵循特定的规则来安全地更新控件。本文将详细介绍两种在子线程中更新UI控件的常用方法。 **1. 使用控件自身的Invoke/BeginInvoke...
C#子线程执行完后通知主线程的方法
09-01
在C#编程中，多线程是常见的并发执行方式，其中主线程通常负责应用程序的主逻辑，而子线程则可以执行一些独立的任务。当子线程完成其工作后，有时需要通知主线程以便进行下一步操作。本文将详细介绍如何在C#中实现...
c#子线程如何读取及设置主线程ui的值
12-14
c#子线程如何读取及设置主线程ui的值，自己录的一个小视频，方便理解，比较菜鸟的方法，请勿喷！
Android主线程和子线程区别详解
01-20
2. Main函数运行在主线程中，其ManagedThreadID与UI界面主线程的ID相等。 3. 主线程不能执行耗时操作，否则会导致UI卡顿，用户体验下降，这通常被称为"ANR"（Application Not Responding）异常。 子线程的特点包括...
线程池创建之后，会立即创建核心线程吗
zlpzlpzyd的专栏
03-21 865
线程池创建之后，会立即创建核心线程吗
线程池参数讲解，及什么时候会创建新线程执行新任务
Fire_Sky_Ho的博客
11-23 2378
public class Principle { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3)); ...
线程池的核心参数及创建
GuoEnze的博客
10-04 377
线程池的核心参数 Core Pool Size 核心线程数目：最多可以保留的线程数 maximum Pool Size 最大线程数目：核心线程+救急线程 keep Alive Time 生存时间 ：针对救急线程 unit 时间单位 ：针对救急线程 work Queue ：阻塞队列 有上限 thread Factory ： 线程工厂 handler ：拒绝策略 当我们创建线程时，线程会优先进入核心线程，如果核心线程数目已满，就进入缓冲队列，如果缓冲队列也被充满，就将进入救急线程，如果救急线程也满了，那么就会
Java线程池初步解读
Robod的博客
11-01 2664
好好学习，天天向上 本文已收录至我的Github仓库DayDayUP：github.com/RobodLee/DayDayUP，欢迎Star 几个月前，写了一篇《Java并发学习(一)：进程和线程》，其中埋了一个坑，说我不会用线程池，毕竟像咱们这种小学生，在学校做的小破项目也用不到线程池这种高大上的东西，所以一直也没学。但是最近不是准备出去打工了嘛，所以线程池还是要学一下的，不然到时候面试官一问，啥也不会大眼瞪小眼，不是很尴尬吗~~~。这不，这两天看了下线程池，搞篇文章总结一下线程池的基本知识????
02. 线程基础知识
m0_46836425的博客
12-14 809
一 创建线程的四种方式 几种方式的对比 继承Thread： 优势：编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程 劣势：线程类已经继承了Thread类，所以不能再继承其他父类 实现Runnable接口或者Callable接口 优势：还可以继续继承别的父类；多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想；其
java线程池杂谈(线程池创建和运行)
高山仰止，景行行止
09-28 1638
继之前写过阿里编码规约对线程池的创建，关于线程池还想再写写自己的理解。1、为啥要有线程池2、线程池怎么创建3、线程池是怎么运行的4、Executors创建线程的弊端下面来一一说一下自己的理解（有说的不对的还请同学不吝赐教）
暑期JAVA学习（36）线程池
xjl243636988的博客
07-31 746
线程池 一、线程池概述 （1）什么是线程池？ （2）不使用线程池的问题 （3）线程池原理 二、线程池实现的API、参数说明 （1）谁代表线程池？ （2）如何得到线程池对象 （3）ThreadPoolExecutor构造器的参数说明 （4）线程池常见面试题 ①临时线程什么时候创建？ ②什么时候会开始拒绝任务？ 三、线程池处理Runnable任务 （1）ThreadPoolExecutor创建线程池对象示例 （2）ExecutorService的常用方法 （3）新任务拒绝策略 （4）具体使用 ...
Java线程池七个参数详解：核心线程数、最大线程数、空闲线程存活时间、时间单位、工作队列、线程工厂、拒绝策略
最新发布
yuanmomoya的博客
08-24 1327
在上述示例中，创建了一个线程池，核心线程数为 5 ，最大线程数为 10 ，空闲线程存活时间为 30 秒，工作队列容量为 100 ，自定义了线程工厂，并使用了默认的拒绝策略。然后向线程池提交了 200 个任务。
多线程相关问题
m0_73774439的博客
08-05 266
核心线程池中的线程默认情况下是当有任务提交的时候才开始创建，而且就算空闲的线程足以处理新任务，它仍然会创建新的线程去处理，直到核心线程数达到最大值，如果调用了prestartAllCoreThreads()方法则会事先创建所有核心线程。正常情况下，核心线程池中的线程一但创建了就不会自动被销毁，除非设置了allowCoreThreadTimeOut=true，或者是线程在执行任务的时候报了异常。
python 主线程与子线程通信
07-29
在 Python 中，主线程和子线程之间可以通过共享变量或队列进行通信。 一种常见的方法是使用共享变量。在主线程中创建一个共享变量，然后将其作为参数传递给子线程。子线程可以修改共享变量的值，主线程可以读取该值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值