【Java】进程

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量1.7k 收藏 25
点赞数 40
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76903988/article/details/136412727
版权

目录

一、进程与线程介绍

二、线程的状态转换

三、创建线程的两种方式

     继承Thread 类 ，重写 run方法

     实现Runnable接口，重写 run方法

 四、线程终止

五、线程常用方法

六、join插队方法

七、守护进程

八、线程同步

九、对象互斥锁

十、线程的死锁

十一、释放锁

     会释放锁

     不会释放锁

一、进程与线程介绍

  1. 进程是程序的一次执行过程或是正在运行的一个程序，动态过程，自身产生，存在，消亡
  2. 线程是由进程创建的，是进程的一个实体，一个进程可以有多个线程：如一起下载多个视频
  3. 单线程：同一时刻，只允许执行一个线程
  4. 多线程：同一时刻，可以执行多个线程
  5. 并发：同一时刻，多个任务交替执行
  6. 并行：同一时刻，多个任务同时执行
  7. 当多个线程进行时，最后一个线程退出程序才会退出

二、线程的状态转换

三、创建线程的两种方式

     继承Thread 类 ，重写 run方法

/**
 * 继承Thread 类创建线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {

        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();

        /*源码：
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0() 是本地方法，是JVM调用, 底层是c/c++实现
            //真正实现多线程的效果， 是start0(), 而不是 run
            private native void start0();

         */

        cat.start();//启动线程-> 最终会执行cat的run方法  start()调用start0()方法是不会立马执行，而是变成可运行状态
        //cat.run();//run方法就是一个普通的方法, 没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
        //说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行，这时 主线程和子线程是交替执行..
        System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字main
        for (int i = 0; i < 80; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠
            Thread.sleep(1000);
        }

    }
}

class Cat extends Thread {

    int times = 0;

    @Override
    public void run() {//重写run方法，写上自己的业务逻辑

        while (true) {
            //该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”
            System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
            //让该线程休眠1秒 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 100) {
                break;//当times 到80, 退出while, 这时线程也就退出..
            }
        }
    }
}

     实现Runnable接口，重写 run方法

  • java是单继承的，在某些情况下一个类可能已经继承了某个父类,这时通过实现Runnable接口来创建线程 
  • 共享：多个线程可以同时进行一个对象
/**
 * 继承Runnable 接口创建线程
 */
public class Thread02 {
    public static void main(String[] args) {

        Thread2 thread2 = new Thread2();
        //T1.start(); 这里不能调用start
        //创建了Thread对象，把 T1对象(实现Runnable),放入Thread  底层静态代理模式
        Thread thread1 = new Thread(thread2);
        thread1.start();//Thread对象去调用start()方法

    }
}

class Thread2 implements Runnable {//通过实现Runnable接口，开发线程
    int temp = 0;//计数

    @Override
    public void run() {
        while (true) {//循环
            System.out.println("你好" + (temp++) + Thread.currentThread().getName());//线程名Thread.currentThread().getName()

            try {//异常处理
                Thread.sleep(500);//休眠时间
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            if (temp == 10) {//判断 当输出到第10次时退出
                break;
            }
        }
    }
}

 四、线程终止

/**
 * 线程终止
 * 可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
 */
public class ThreadExit {
    public static void main(String[] args) throws InterruptedException {
        Exit exit = new Exit();
        exit.start();//启动线程 -> 执行run方法

        Thread.sleep(10 * 1000);//当主线程休眠结束时
        exit.setLoop(false);//调用setLoop() 方法 将false 传入setLoop 方法中

    }

}

class Exit extends Thread {
    private boolean loop = true;
    int temp = 0;

    @Override
    public void run() {

        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(temp++);
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }//主线程中传入 将 loop = false 循环停止
}

五、线程常用方法

/**
 * setName//设置线程名称，使之与参数 name 相同
 * getName //返回该线程的名称
 * getState()//获取线程状态
 * start //使该线程开始执行;Java 虚拟机底层调用该线程的 start0 方法
 * run //调用线程对象 run 方法:
 * setPriority //更改线程的优先级
 * getPriority //获取线程的优先级
 * sleep//在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
 * interrupt //中断线程
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关的方法
        T t = new T();
        t.setName("嘿嘿");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();

        //主线程打印5 hi ,然后中断 子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
        System.out.println("线程的名字=" + t.getName() + "线程的优先级=" + t.getPriority());
        t.interrupt();//当执行到这里，就会中断 t线程的休眠.
    }
}

class T extends Thread { //自定义的线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

六、join插队方法

/**
 *join插队方法
 */
public class ThreadJoin {
    public static void main(String[] args) throws InterruptedException {
        Join join = new Join();
        Thread thread = new Thread(join);


        for (int i = 1; i <= 10; i++) {
            Thread.sleep(100);
            System.out.println("少爷吃了" + i + "个槟榔");
            if (i == 5) {
                thread.start();
                thread.join();//插队
            }
        }
    }
}

class Join implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("少爷玩了" + i + "局梦三国");
        }
    }
}

七、守护进程

  • 守护线程:一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束常见的守护线程:垃圾回收机制
/**
 * 守护线程
 */
public class setDaemon {
    public static void main(String[] args) throws InterruptedException {

        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当main线程结束后，子线程自动结束
        //只需将子线程设为守护线程即可
        myDaemonThread.setDaemon(true);//setDaemon(true) 将子线程设置为守护线程  先设置，再启动
        myDaemonThread.start();

        for (int i = 1; i <= 10; i++) {//main线程
            System.out.println("辛苦的工作...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        for (; ; ) {//无限循环
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("快乐聊天，哈哈哈~~~");
        }
    }
}

八、线程同步

  • 线程同步：当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作，以保证数据的完整性。
/**
 * 同步具体方法-Synchronized
 * 1.同步代码块
 * synchronized(对象){
 * //得到对象的锁，才能操作同步代码
 * // 需要被同步代码;
 * }
 * 2.synchronized还可以放在方法声明中，表示整个方法-为同步方法
 * public synchronized void s(String name){
 * //需要被同步的代码
 * }
 */
public class SellTicket02 {
    public static void main(String[] args) {

        SellTick sellTick01 = new SellTick();

        new Thread(sellTick01).start();
        new Thread(sellTick01).start();
        new Thread(sellTick01).start();

    }
}

//同步方法
class SellTick implements Runnable {
    int temp = 80;//让多个线程共享
    private boolean loop = true;//控制run方法变量

    public synchronized void sell() {//同步方法, 在同一时刻， 只能有一个线程来执行sell方法
        if (temp <= 0) {
            System.out.println("售票结束");
            loop = false;
            return;
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        System.out.println("窗口" + Thread.currentThread().getName() + "卖了一张票" + "还剩" + (--temp) + "张票");
    }


    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}


//同步代码块
/*class SellTick02 implements Runnable {//同步代码块
    int temp = 80;//让多个线程共享
    private boolean loop = true;//控制run方法变量

    public void sell() {

        synchronized (this) {//同步代码块
            if (temp <= 0) {
                System.out.println("售票结束");
                loop = false;
                return;
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("窗口" + Thread.currentThread().getName() + "卖了一张票" + "还剩" + (--temp) + "张票");
        }
    }

    @Override
    public void run() {
        while (loop) {
            sell();
        }
    }
}
*/

九、对象互斥锁

  1. 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
  2. 关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时表明该对象在任一时刻只能由一个线程访问
  3. 同步的局限性:导致程序的执行效率要降低
  4. 同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
  5. 同步方法(静态的)的锁为当前类本身
class SellTick03 implements Runnable {//同步方法(静态的)的锁为当前类本身
    public static void sell() {
        synchronized (SellTick03.class) {//锁为当前类本身
            System.out.println("静态");
        }
    }

    @Override
    public void run() {

    }
}

十、线程的死锁

  • 多个线程都占用了对方的锁资源但不肯相让，导致了死锁

/**
 *死锁情况
 */
public class ThreadDeadLock {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();

    }

}

//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
    static Object o2 = new Object();
    boolean loop;

    public DeadLockDemo(boolean loop) {//构造器
        this.loop = loop;
    }

    @Override
    public void run() {

        //1. 如果loop 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        //2. 如果线程A 得不到 o2 对象锁，就会Blocked
        //3. 如果loop 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
        //4. 如果线程B 得不到 o1 对象锁，就会Blocked
        if (loop) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }

            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

十一、释放锁

     会释放锁

  1. 当前线程的同步方法、同步代码块执行结束
  2. 当前线程在同步代码块、同步方法中遇到break、return
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

     不会释放锁

  1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁
  2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起该线程不会释放锁。提示:应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
彼岸、未歇
关注
  • 40
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 进程
qq_68656640的博客
09-21 301
1). 预处理(将包含的头文件全部引入 宏定义全部替换 注释全部删除等)2.) 编译(将文本程序转换成汇编程序并检查代码的规范性、是否有语法错误,每个c语言文件都会有一个表格,这个表格中记录了每个函数的名字 以及 参数 和 地址,编译阶段则会将这些表格合在一起,如果函数名重复 但是地址不重复 且 其中一个地址为空 那么会认为不为空的那个地址,就是函数所在的地址,如果两个地址都为空 那么会报错,如果说两个地址都不为空 就是说 有两个相同名的函数 那么也会报错)
【Java】线程
大珍珠
06-17 256
线程
查看java进程
qq_25073223的博客
06-09 6377
获取进程编号的方法
JAVA进程和线程
程序猿追的博客
11-06 8688
进程就是正在运行的程序，它是系统资源调度的独立单位，并且一个进程可以执行多个任务，而线程就是程序执行的任务，它是程序使用CPU的基本单位，因此也可以说线程是依赖于进程的。像比如任务管理器里面的运行任务就是线程。
java 进程名_修改java进程名称
weixin_29291185的博客
02-21 1447
当同一个服务器上启动多个tomcat后，我们会在任务管理器中看见多个java.exe，当我们需要对某个tomcat进行监控时，却无法区分出该tomcat的进程，那么如何修改进程名呢？可以使用端口号来区分不同的tomcat进程，使用netstat -nao | find "xxxx",xxxx是端口号，就可以找到所对应的进程。下面的方法可以直接修改tomcat的进程名为指定的名字，更便于辨认。1、修...
java 进程通信 实例（直接运行）
08-03
本人写了一个java进程通信的工具jar，方便大家简单的使用java进程通信。 开启守护进程，获取消息： package com.test; import org.msun.process.ProcessMonitor; import org.msun.process.ProcessMonitor....
JAVA进程突然消失问题解决方案
08-19
在Java开发过程中，有时会遇到一个棘手的问题，即Java进程突然消失，这可能是由多种因素造成的。本文将深入探讨几种可能导致这种情况的原因，并提供相应的解决方案。 首先，我们要了解Linux操作系统中的一个关键...
java进程通信.zip
09-02
本资料包“java进程通信.zip”可能包含详细讲解Java进程通信的文档或代码示例。 在Java中，主要的进程通信方法有以下几种： 1. **管道（Pipes）**：Java通过`java.io.PipedInputStream`和`java.io....
Java如何获取当前进程ID以及所有Java进程的进程ID
08-30
Java如何获取当前进程ID以及所有Java进程的进程ID Java 获取当前进程ID是指在 Java 程序中获取当前进程的 ID 号码，而获取所有 Java 进程的进程 ID 则是指获取所有当前正在运行的 Java 进程的 ID 号码。这些信息...
java进程间管道通信1
08-08
Java进程间的管道通信是一种进程间通信（IPC，Inter-Process Communication）的方式，它允许不同的Java进程之间通过共享的管道进行数据传输。虽然Java标准库不直接支持创建管道文件，但可以借助于操作系统提供的功能...
配置Java开发环境
最新发布
Broken_x的博客
07-10 658
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 246
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1141
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 302
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 2510
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
qq_44304677的博客
07-09 752
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 540
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 1039
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
基于SpringBoot的招聘信息管理系统的详细设计和实现(源码+lw+部署文档+讲解等，欢迎咨询我！！)
程序员阿龙的博客
07-06 1359
本次分享的是一个基于java开发的招聘信息管理系统，也说明了自己的开发实力，欢迎各位小伙伴来咨询相关业务，也可以参考一下这个文章！！
linux java进程
05-26
Java进程在Linux系统中与其他进程一样，也需要通过终端命令来启动、停止、查看状态等操作。 1. 启动Java进程 在Linux系统中，启动Java进程需要使用java命令，具体命令格式如下： ``` java [options] class [args....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值