Java 进程与线程

已于 2023-03-03 08:44:12 修改
阅读量557 收藏 4
点赞数
分类专栏： Java基础 文章标签： java jvm 开发语言 Powered by 金山文档
于 2023-03-02 21:15:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65030141/article/details/129309357
版权

零、复习昨日

二、进程与线程

一个==进程就是一个应用程序，进程包含线程==
一个进程至少包含一个线程，大部分都是多线程在执行任务(多线程)
==进程是系统资源分配的最小单位==
==线程是进程内部的一个执行任务==
进程内多个线程是共享进程资源，==线程是资源调度的最小单位==
Java程序是多线程：main线程、垃圾回收线程等等

三、创建进程【重要】

创建线程的方式

==继承thread==
==实现Runnable接口==
使用Callable 和 Future 来完成
使用线程池获得线程

3.1 继承Thread

步骤
1、自定义类
2、继承Thread
3、重写 run 方法
4、创建子类对象
5、==调用 start 方法启动线程 【特别强调，开启新线程的方法是 start】== start 方法里面有 run 方法 
public class MyThread extends Thread{
    // 重写方法,方法内部,就是该线程执行的任务
    @Override
    public void run() {
        for (int i = 1; i < 11; i++) {
            System.out.println("myThread ---> "+ i);
        }
    }
}
public static void main(String[] args) {
    // 创建一个线程
    MyThread myThread = new MyThread();

    // 启动线程
    myThread.start();

    // main线程执行
    for (int i = 1; i < 11; i++) {
        System.out.println("main ---> " + i);
    }
}
    // 自定义线程和主线程同时执行，并且出现资源城墙情况
使用匿名内部类的形式开启线程 
// 匿名内部类开启线程
new Thread(){
    @Override
    public void run() {
        for (int i = 1; i < 11; i++) {
            System.out.println("my-Thread ---> " + i);
        }
    }
}.start();

myThread线程，main线程，my-Thread线程3个在争抢资源，如果没有出现效果，把主线程执行的代码放在最下方，因为主线程代码优先级较高。会优先执行……

3.2 实现Runnable接口

步骤
1、自定义类
2、实现 Runnable 接口
3、重写 run 方法
4、创建子实现类对象
5、把子实现类对象当构造方法的方法参数来创建 Thread 对象
6、由 thread 调用 start 方法开启线程 
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i < 11; i++) {
            System.out.println("Runnable1 --> " + i);
        }
    }
}

public static void main(String[] args) {
        // 4 创建实现类对象
        MyRunnable myRunnable = new MyRunnable();

        // 5 把对相当构造方法参数，创建Thread对象
        Thread thread = new Thread(myRunnable);
        // 6 开启线程
        thread.start();

        // main线程执行
        for (int i = 1; i < 11; i++) {
            System.out.println("main --> " + i);
        }
}
使用匿名内部类的形式创建线程 
// 匿名内部类实现 Runnable 接口
new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 1; i < 11; i++) {
            System.out.println("Ruannable2 --> " + i);
        }
    }
}).start();

3.3 区别

继承 Thread 开启线程和实现 Runnable 接口开启线程有什么区别？

一个继承；一个实现
继承 Thread 后，直接创建对象即可调用 start 开启线程
实现 Runnable 接口的子类，还需要再创建 Thread 类对象才会开始调用 start 开启线程
继承 Thread 类就限制了该类在继承别的类，因为类只能单继承；而实现接口的同时可以继承别的类，并且允许多继承。
所以推荐使用接口来实现

四、线程的API

==void start() 开启线程==,会自动run方法执行线程任务
==void run() 执行线程的方法==
run() 方法是start开启线程后,JVM自动调用
void setName(String name) 给线程设置名字
也可以通过构造方法,在创建线程时指定线程名
String getName() 获得线程的名字
==static Thread currentThread()== 返回当前正在执行的线程对象
setPriority(int priority) 设置优先级
级别是1-10 ,默认是5
getPriority() 获得优先级
join() 加入线程,等待该线程终止
join(int milles) 加入线程,最大等待直到毫秒数
void setDaemon(boolean on) 设置守护线程
==static== void yield() 礼让线程,暂停当前线程,让其他线程执行
==static void sleep(long milles) 线程休眠==
会让当前线程暂停执行,==让出系统资源==,让其他线程执行
时间到,当前会继续和其他争抢资源执行
void stop() 结束当前线程,线程死亡(已过式)
被废弃的原因是因为这个中断线程太直接太暴力... 
package com.qfFirst.qf0302.haveClass;

import com.qfFirst.qf0216.T.T;

/**
 * @escription:
 * @author:等，一起
 * @data:
 */

public class TestThread3 {
    public static void main(String[] args) {
//        testName();

//        testPriority();

//        testDaemon();

//        testYield();

//        testJoin();

//        testSleep();

        testStop();
    }

    public static void testName(){
        // 通过构造方法设置线程名
        Thread thread = new Thread("和谐号"){
            @Override
            public void run() {
                for (int i = 1; i < 11; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        Thread thread2 = new Thread(){
            @Override
            public void run() {
                for (int i = 1; i < 11; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };
        // 默认线程名，从Thread-0开始
//        System.out.println(thread.getName());
//        System.out.println(thread2.getName());

        // 通过setName设置线程名
        thread2.setName("绿皮");

        thread.start();
        thread2.start();
    }

    public static void testPriority(){
        // 优先级
        // 通过构造方法设置线程名
        Thread thread = new Thread("和谐号"){
            @Override
            public void run() {
                for (int i = 1; i < 11; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        Thread thread2 = new Thread("复兴号"){
            @Override
            public void run() {
                for (int i = 1; i < 11; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        // 默认优先级 5
        System.out.println(thread.getName()+"-->"+ thread.getPriority());
        System.out.println(thread2.getName()+"-->"+ thread2.getPriority());

        // 设置优先级，最高10，最低1，不能越界
        // 注意不是优先级高的先执行，只是大概率上会是
        thread.setPriority(1);
        thread2.setPriority(10);

        thread.start();
        thread2.start();

        // 获得主线程名字，优先级 5
        System.out.println(thread.getName());
    }

    public static void testDaemon(){
        // 守护线程
        // 通过构造方法设置线程名
        Thread thread = new Thread("将军"){
            @Override
            public void run() {
                for (int i = 1; i < 2; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        Thread thread2 = new Thread("士兵"){
            @Override
            public void run() {
                for (int i = 1; i < 11; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        // 开启前设置守护线程
        thread2.setDaemon(true);
        // 一旦设置一个线程为守护线程，其余线程就是被守护的
        thread.start();
        thread2.start();
    }

    public static void testYield(){
        // 礼让线程
        // 通过构造方法设置线程名
        Thread thread = new Thread("红方"){
            @Override
            public void run() {
                for (int i = 1; i < 110; i++) {
                    // 获得当前正在执行线程对象
                    if (i == 50){
                        Thread.yield();
                    }
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        Thread thread2 = new Thread("蓝方"){
            @Override
            public void run() {
                for (int i = 1; i < 110; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        thread.start();
        thread2.start();
    }

    public static void testJoin(){
        // 加入线程
        // 通过构造方法设置线程名
        Thread thread = new Thread("红方"){
            @Override
            public void run() {
                for (int i = 1; i < 110; i++) {
                    // 获得当前正在执行线程对象
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        Thread thread2 = new Thread("蓝方"){
            @Override
            public void run() {
                for (int i = 1; i < 110; i++) {
                    // 获得当前正在执行线程对象
                    if (i == 50){
                        try {
                            thread.join();
                            //线程 蓝方 执行到50，让 红方 加入执行，直到结束，蓝方在执行

                            // 蓝方 到50，让红方加入线程执行指定毫秒值，到时间再继续争抢
//                            thread.join(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };

        thread.start();
        thread2.start();
    }

    public static void testSleep(){
        // 睡眠效果
        // 通过构造方法设置线程名
        Thread thread = new Thread("红方"){
            @Override
            public void run() {
                for (int i = 5; i > 0; i--) {
                    // 线程休眠1秒钟
                    System.out.println(i);
                    try{
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("发射！");
            }
        };

//        Thread thread2 = new Thread("蓝方"){
//            @Override
//            public void run() {
//                for (int i = 1; i < 110; i++) {
//                    // 获得当前正在执行线程对象
//                    System.out.println(Thread.currentThread().getName()+"-->"+i);
//                }
//            }
//        };

        thread.start();
//        thread2.start();
    }

    public static void testStop() {
        // 线程中断
        // 通过构造方法设置线程名
        Thread thread = new Thread("红方") {
            @Override
            public void run() {
                for (int i = 1; i < 110; i++) {
                    // 线程休眠1秒钟
                    if (i == 50){
                        Thread.currentThread().stop();
                    }
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };
        thread.start();
    }
}

五、线程状态[面试]

线程的几种状态：
创建/新建/初始
new完线程对象
就绪
调用start
等待/阻塞
join()或者sleep()
运行
执行run()方法
死完/销毁/种植
run方法执行完，或者调用stop()或者 interrupt()中断等

清楚状态之间的转换

六、线程安全【重点】

6.1 线程安全

临界资源：共享资源（同一个对象），一次只可以有一个线程操作，才可以保证准确性
原子操作：不可拆分的步骤，被视作一个整体。其步骤不能被忽视

线程不安全：1）完整的步骤可能会被破坏 ；2）线程内的数据可能被别的线程修改

6.2 线程安全方式

同步方法
给方法加锁，及设置同步关键词==synchronized==
锁是当前对象，即this
同步代码块
将需要安全的代码使用同步代码块包裹，设置锁对象
==锁可以是任意对象==
但是线程之间应该是==同一把锁==才能锁住，

其实就是给需要“同步”，需要“安全”，需要“步骤一直，不能打乱”的代码==加锁==

需求：要求打印机类的两个方法分别被两个线程同时执行。但是方法执行时不能被破坏，即方法执行是不能被另外一个线程抢走资源，要保证方法执行是步骤完整性

// 同一把锁（对象）
private Object obj = new Object();
// 打印机1号
public synchronized void printer1(){
    synchronized (obj){
        System.out.print(1 + " ");
        System.out.print(2 + " ");
        System.out.print(3 + " ");
        System.out.print(4 + " ");
        System.out.println();
    }
}

// 打印机2号
public synchronized void printer2(){
    synchronized (obj){
        System.out.print("一");
        System.out.print("二");
        System.out.print("三");
        System.out.print("四");
        System.out.println();
    }
}
public static void main(String[] args) {
        Printer printer = new Printer();

        new Thread(){
            @Override
            public void run() {
                while (true){
                    printer.printer1();
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true){
                    printer.printer2();
                }
            }
        }.start();
    }
}

6.3 转账案例

需求：假设银行专户类，属性有卡号、余额、名字；有ATM机器。机器内部能接收帐户，给ATM指定取的钱数。多台

// 账户
public class Account {

    private String id;
    private double balance;

    public Account() {
    }

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

    public String getId() {
        return id;
    }

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}
public class ATM extends Thread {

    private Account account;
    private double money;
    // 取钱是多线程操作
    @Override
    public void run() {
        synchronized (ATM.class){
            if (account.getBalance() >= money) {
                // 模拟出钱的时间,目的是让出资源,让另外的线程执行,模拟争抢
                // 加锁后,sleep"抱着锁睡觉",是说线程休眠不会让出锁,即不会让出资源,其他线程无法执行,
                // 等着这个线程休眠结束并且执行完毕
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace( );
                }
                account.setBalance(account.getBalance() - money);
                System.out.println(Thread.currentThread().getName() + "取钱成功,取出" +money );
                System.out.println("余额:" + account.getBalance() );

            } else {
                System.out.println("你有多少钱,心里没数?!" );
            }
        }
    }

    public ATM() {
    }

    public ATM(Account account, double money,String name) {
        super(name);
        this.account = account;
        this.money = money;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public double getMoney() {
        return money;
    }

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

    public static void main(String[] args) {
        Account account = new Account("888888", 1000);
        new ATM(account,600,"小红").start();
        new ATM(account,600,"小黑").start();
    }
}
变式: 转账案例使用Runable接口来实现
练习

售票: 有一个窗口类售票,总共100张票,窗口不止一个可以多个窗口同时售票. 要保证票不能卖超,不能卖重复的票

6.4 线程安全的方式

不只有synchronized同步方法可以保证线程安全,其实还有很多
ThreadLocal
Volatile
Lock
ReentrantLock
等

单词：

thread：线程；
Wait Together
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java-进程和线程
wrb88881203的博客
04-14 154
了解线程和进程
【JAVA】线程和进程
m0_55394328的博客
03-02 1274
多线程是提升程序性能非常重要的一种方式，也是Java 编程中的一项重要技术。在程序设计中，多线程就是指一个应用程序中有多条并发执行的线索，每条线索都被称作—个线程，它们会交替执行，彼此可以通信。以上就是今天的学习内容啦~如果有兴趣的话可以订阅专栏，持续更新呢~咱们下期再见~
Java进程与线程
微信公众号：饺子泡牛奶
03-27 1953
你可能已经很熟悉多任务（multitasking），这是操作系统的一种能力，看起来就可以在同一时刻运行多个程序。 例如，在编辑或下载邮件的同时可以打印文件等场景。 一、线程 1.1 什么是线程？ 线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位。 一个进程可以有一个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。 一个标准的线程由线程ID，当前指令指针PC，寄存器和堆栈组成。而进程由内存空间(代码，数据，进程空间，打开的文件.
【Java多线程学习1】什么是进程、线程，什么是并发、并行及线程的创建和线程的基本使用
weixin_43950588的博客
01-02 847
什么是线程、进程，什么是并发、并行及线程的创建和基本使用
acnuire-miss.zip_进程与线程_Java_
08-10
总的来说，这个压缩包提供了一组关于Java进程与线程的实践示例，特别是针对音频处理的多线程编程。通过学习这些代码，开发者可以了解如何在Java中有效地利用多线程技术处理音频数据，提升应用程序的性能和响应性。
java线程进程锁资源
02-12
**进程与线程的区别** 1. **进程**：是操作系统资源分配的基本单位，每个进程都有独立的内存空间，包括程序代码、数据和栈空间等。 2. **线程**：是CPU调度的基本单位，同一进程内的线程共享进程的内存空间和资源，...
mgbqhol.zip_进程与线程_Java_
08-10
在Java编程领域，进程与线程是两个非常重要的概念，它们是操作系统中并行处理任务的基本单位。在本文中，我们将深入探讨这两个概念以及它们在Java中的应用。 首先，我们来理解什么是进程。进程可以被定义为一个正在...
bank.rar_进程与线程_Java_
08-12
在Java编程语言中，进程与线程是操作系统中并发执行的基本单位。理解并熟练掌握这两个概念对于开发高效、可靠的多任务应用至关重要。标题"bank.rar_进程与线程_Java_"提示我们，这个压缩包中的内容可能是一个示例...
Java_Thread.rar_进程与线程_Java_
08-11
在计算机科学中，进程和线程是操作系统中的两个基本概念，尤其在Java编程语言中，理解和掌握它们对于高效地开发多任务应用至关重要。本篇将深入探讨这两个概念以及Java中如何处理它们。 首先，让我们从“进程”开始...
【java学习】进程、线程、程序
午后阳光
07-27 3879
1，概念 （1）分类 ①守护线程（Daemon Thread） 用户线程可以通过System.exit(status)（status为0时表示正常退出，非0表示非正常退出）来退出JVM。 父线程是守护线程子线程默认为守护线程，父线程是用户线程子线程默认为用户线程。父线程在创建子线程后，启动子线程之前，可以调用Thread实例的setDaemon方法来修改线程属性。 当没有用户线程...
java基础多线程--进程与线程：
最新发布
m0_49102053的博客
04-30 99
java基础--多线程
Java进程和线程
qq_45667640的博客
03-28 140
Java中进程和线程的介绍
Java中的进程和线程
LiZongShao的博客
04-01 191
进程是一个独立运行的应用程序。比如电脑软件，启动以后就是一个进程，如QQ等。进程需要系统进行分配，可以获取当前系统的内存、网卡、显卡等进程的两个特性：①独立性：各个进程之间是相互独立互不影响的。②互斥性：每个应用程序系统会分配一个独立的端口号。
进程
weixin_34060299的博客
09-23 107
1.进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体...
java如何写进程_java写出进程条代码
weixin_32052253的博客
02-26 184
package com.ds;import java.awt.Color;import java.awt.Toolkit;import javax.swing.ImageIcon;import javax.swing.JLabel;import javax.swing.JOptionPane;import javax.swing.JProgressBar;import javax.swing.JW...
java线程与进程
mmoren的博客
03-26 5480
线程：1）进程中负责程序执行的执行单元2）依靠程序执行的顺序控制流，只能使用程序的资源和环境，共享进程的全部资源3）有自己的堆栈和局部变量，没有单独的地址空间4）CPU调度和分派的基本单位，持有程序计数器，寄存器，堆栈进程：1）系统资源分配和调度的独立单位2）至少包含一个线程3）拥有自己的资源创建线程的方式：1）继承Thread类，实现run方法2）实现Runnable接口，实现run方法，用实现...
java进程与线程（适合新人）
qq_41566219的博客
12-22 210
java进程与线程 进程与线程这一块的知识一向是初学者比较容易迷惘的地方，所以这一次我详细，并且通俗的讲解一下，什么是进程，线程。 一,什么是进程 首先，我们先来解释一下什么是进程！ 进程是由多个线程组成的！！！ 在我们正常使用电脑的时候，你会发现，每当我们打开一个软件，比如qq，然后你再打开任务管理器的进程页面，就会发现，属于qq的进程出现了。 而当你使用任务管理器关闭qq进程的时候，打开的qq...
java进程和线程学习
叶子一哥
04-25 2276
1.进程与线程

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值