Java进程--简单讲解

最新推荐文章于 2023-02-16 13:31:29 发布
最新推荐文章于 2023-02-16 13:31:29 发布
阅读量758 收藏 1
点赞数
分类专栏： JAVA基础 文章标签： 线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_Jun0112/article/details/76280821
版权

线程和进程

  • 进程：在操作系统中能（同时）运行多个任务（程序），每一个应用程序就是进程。
  • 线程：在一个程序中同时运行额多个独立流程，每一个独立的流程就是一个线程。
  • 每一个Java程序都至少有一个线程–主线程，当一个Java程序启动时，JVM会创建这个主线程，并且在这个主线程上调用main()方法。
  • 线程并发：多个线程同时执行（多个线程轮流分配cpu的时间片，并不是真正的同时执行)。
    这里写图片描述

线程开发

  • 线程开发有两种方式：
    • 继承Thread类
    • 实现Runnable接口

继承Thread类

  • 继承Thread类开发线程

    • 用户定义一个类继承Thread类
    • 覆盖run方法

    • 运行线程

       class MyThread extends Thread{
     public void run(){
         for(int i =1; i<=1000; i++) {
             System.out.println(i+"$$$");
         }
    }
}
class MyThread2 extends Thread{
    public void run() {
        for(int i=1; i<=1000; i++) {
            System.out.println(i+"###");
        }
    }
}

    public class TestThread {
        public static void main(String args[]) {
            Thread t1 = new MyThread1();
            Thread t2 = new MyThread2();
            //启动线程，输出顺序是随机的
            t1.start();
            t2.start();
        }
    }

实现Runnable接口

  • Runnable接口开发线程
    • 用户开发一个类实现Runnable接口
    • 实现run();
    • 运行线程
      Runnable target = newMyRunnable2();
      Thread t2 = new Thread(target);
示例
    class MyThread1 extends Thread {
        public void run() {
            for(int i = 1; i<=1000; i++ ) {
                System.out.pintln(i+"$$$");
            }
        }
    }
    class MyRunnable2 implements Runnable {
        public void run() {
            for(int i = 1; i<=1000; i++) }
                System.out.println(i+"###");
            }
        }
    }
    public class TestThread {
        //第一种方式
        Thread t1 = new MyRunnable1();
        //第二种方式
        Runnable target = new MyRunnale2();
        Thread t2 = new Thread(target);
        t1.start();
        t2.start();
    }
}
两种方式对比
  • 继承Thread上面向对象的编程方式
  • 实现Runnable接口解决了单一继承的限制

  • 二者都可采用匿名内部类的方式，如果线程只在一处使用，可以选择这种方式，但是可读性较差。

     new Thread() {
     @Override
     public void run() {
         for(int i = 1; i<=1000; i++) {
             System.out.println(i+"$$$");
        }
    }
}.start();

new Thread(new Runnable() {
    @Overrider
    public void run() {
        for(int i = 1; i<=1000; i++) {
            System.out.println(i+"###");
        }
    }
}).start();

线程的状态

  • 线程的状态分为5种，初始、可运行、运行、阻塞、以及终止等。
    这里写图片描述

线程的调度与控制

  • 通常我们的计算机知识一个CPU，CPU在某一个时刻只能执行一条指令，线程知识得到CPU时间片，也就是使用权，才可以执行指令。在单CPU的机器上线程不是并行运行的，只有在多个CPU的使用权，目前按有两种调度模型：分时调度模型和抢占式调度模型，Java使用抢占式调度模型。
    • 分时调度模型，所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU时间片。
    • 抢占式调度模型，优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个。

线程优先级

  • 线程优先级主要分三种

    • MAX_PRIORITY(最高级);
    • MIN_PRIOITY(最低级);

    • NOM_PRIORITY(标准)默认；

      public class ThreadTest04 {
    public static void main(String[] args) {
        Runnable r1 = new Processor();
        Thread t1 = new Thread(r1, "t1");
        //设置线程的优先级，线程启动后不能再次设置优先级
        //必须在启动前设置优先级
        //设置最高优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        //启动线程
        t1.start();

        //取得线程名称
        //System.out.println(t1.getName());

        Thread t2 = new Thread(r1, "t2");
        //设置最低优先级
        t2.setPriority(Thread.MIN_PRIORITY);
        t2.start();
            System.out.println(Thread.currentThread().getName());
    }   
}

    class Processor implements Runnable {
           public void run() {
              for (int i=0; i<100; i++) {
                     System.out.println(Thread.currentThread().getName() + "," + i);
              } 
            }   
    }
    /**
     *从输出结果应该看可以看出，
     *优先级高的线程（t1）会得到的
     *CPU时间多一些，优先执行完成
     **/

sleep和join还有yeild

Thread.sleep

  • sleep设置休眠的时间,单位毫秒，当一个线程遇到sleep的时候，就会睡眠，进入到阻塞状态,放弃CPU，腾出cpu时间片，给其他线程用，所以在开发中通常我们会这样做，使其他的线程能够取得CPU时间片，当睡眠时间到达了，线程会进入就绪状态，得到CPU时间片继续执行，如果线程在睡眠状态被中断了，将会抛出IterruptedException

        public class ThreadTest05 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            Thread t2 = new Thread(r1, "t2");
            t2.start();
        }   
    }

    class Processor implements Runnable {   
        public void run() {
            for (int i=0; i<100; i++) {
        System.out.println(Thread.currentThread().getName() + "," + i);
            if (i % 10 == 0) {
            try {
                //睡眠100毫秒，主要是放弃CPU的使用，将CPU时间片交给其他线程使用
                Thread.sleep(100);
            }catch(InterruptedException e) {
                e.printStackTrace();    
            }
        }
    }   
}

    }

Thread.join

  • 当前线程可以调用另一个线程的join方法，调用后当前线程会被阻塞不再执行，直到被调用的线程执行完毕，当前线程才会执行

        public class ThreadTest07 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            try {
                t1.join();
            }catch(InterruptedException e) {
                    e.printStackTrace();    
            }
            System.out.println("------main end-------");
        }   
}

class Processor implements Runnable {
        public void run() {
            for (int i=0; i<10; i++) {
                System.out.println(Thread.currentThread().getName() + "," + i);
            }   
    }   
}
Thread.yield

  • 它与sleep()类似，只是不能由用户指定暂定多长时间，并且yield()方法只能让同优先级的西安城有执行的机会。

        public class ThreadTest06 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            Thread t2 = new Thread(r1, "t2");
            t2.start();
        }   
    }
    class Processor implements Runnable {
        public void run() {
            for (int i=0; i<100; i++) {
                System.out.println(Thread.currentThread().getName() + "," + i);
                if (i % 10 == 0) {
                    System.out.println("--------------");
                    //采用yield可以将CPU的使用权让给同一个优先级的线程
                    Thread.yield();
            }
        }   
    }   
}
sleep、join、yeild关系
  • sleep()使当前线程进入停滞状态，所以执行sleep的线程在指定的时间内肯定不会执行；sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会。
  • join方法也会导致线程阻塞
    • 特点：如果当前线程中调用了另外一个线程的join方法，单签线程会立即阻塞，直到另外一个线程运行完成。
  • yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，yield()只能使同优先级的线程有执行的机会。

interrupt(中断)

  • 如果我们的线程正在睡眠，可以采用interrupt进行中断

         public class ThreadTest08 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            try {
                //设置为500毫秒，没有出现中断异常，因为500毫秒之后再次调用t1.interrupt()时，
                //此时的睡眠线程已经执行完成
                //如果sleep的时间设置的小一些，会出现中断异常，因为存在睡眠线程
                Thread.sleep(500);
            }catch(Exception e) {
                e.printStackTrace();
            }
        //中断睡眠中的线程
        t1.interrupt();
    }   
}

class Processor implements Runnable {   
    public void run() {
        for (int i=1; i<100; i++) {
            System.out.println(Thread.currentThread().getName() + "," + i);
            if (i % 50 == 0) {
                try {
                    Thread.sleep(200);  
                }catch(Exception e) {
                    System.out.println("-------中断-------");
                    break;              
                }
            }
        }   
    }   
}
如何正确的停止一个线程

  • 通常定义一个标记，来判断标记的状态停止线程的执行。

         public class ThreadTest09 {
        public static void main(String[] args) {
            //Runnable r1 = new Processor();
            Processor r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

        try {
            Thread.sleep(20);
        }catch(Exception e) {}
            //停止线程
            r1.setFlag(true);
        }   
    }
    class Processor implements Runnable {   
        //线程停止标记，true为停止
        private boolean flag;

        public void run() {
            for (int i=1; i<100; i++) {
                System.out.println(Thread.currentThread().getName() + "," + i);
                //为true停止线程执行
                if (flag) {
                    break;
                }
            }   
        }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }   
}

为什么需要同步

  • 【示例代码】，取得0~10的和采用相同的线程对象启用两个线程进行计算（共享一个对象启动两个线程）

            public class ThreadTest10 {
            public static void main(String[] args) {
                Runnable r1 = new Processor();
                Thread t1 = new Thread(r1, "t1");
                t1.start();

                Thread t2 = new Thread(r1, "t2");
                t2.start();

        }   
    }
    class Processor implements Runnable {   
            public void run() {
                //定义局部变量s，作为累加变量
                int s = 0;
                for (int i=0; i<10; i++) {
                    s+=i;
                }   
            System.out.println(Thread.currentThread().getName() + ", s=" + s);
        }
}

    以上t1和t2并发执行，s为每个线程的局部变量，位于各自的栈帧中，因为栈帧中的数据是不会互相干扰的，所有计算结果都为45

线程同步

  • 【示例代码】，取得0~10的和采用两个线程进行计算，将s改为成员变量(共享一个对象启动两个线程)

        public class ThreadTest11 {

        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();

            Thread t2 = new Thread(r1, "t2");
            t2.start();

    }   
}
class Processor implements Runnable {
    //定义成员变量s，作为累加变量    
    private int s = 0;  
    public void run() {
        for (int i=0; i<10; i++) {
            s+=i;
        }   
        System.out.println(Thread.currentThread().getName() + ", s=" + s);
    }
}

    这回两个线程的结果不一致了。为什么出现以上的问题，因为共享了同一个对象的成员变量s，两个线程同时对其进行操作，所以产生了问题，此时称为此时Processor为线程不安全的，如果想得到正确的结果，必须采用线程同步，加锁，该变量才能共享使用

  • 产生数据不一致的原因
    • 多个线程并发访问了同一个对象，如果破坏了不可分割的操作，从而就会造成数据不一致
  • 临界资源
  • 原子操作
  • 被多线程并发访问时如果一个对象有可能出现数据不一致的问题，那么这个对象称为线程不安全的对象

使用线程同步

  • 线程同步，指某一个时刻，指允许一个线程来访问共享资源，线程同步其实是对对象加锁，如果对象中的方法都是同步方法，那么某一时刻只能执行一个方法，采用线程同步解决以上的问题，我们只要保证线程1操作s时，线程2不允许操作即可，只有线程1使用完成s后，再让线程2使用s变量。

    public class ThreadTest12 {
    public static void main(String[] args) {
        Runnable r1 = new Processor();
        Thread t1 = new Thread(r1, "t1");
        t1.start();     
        Thread t2 = new Thread(r1, "t2");
        t2.start();
    }   
}
class Processor implements Runnable {
    //定义成员变量s，作为累加变量    
    private int s = 0;  
    //synchronized是对对象加锁,采用synchronized同步最好只同步有线程安全的代码
    //可以优先考虑使用synchronized同步块因为同步的代码越多，执行的时间就会越长，
    //其他线程等待的时间就会越长影响效率
    //public synchronized void run() {
        //使用同步块
        synchronized (this) { 
            for (int i=0; i<10; i++) {
                s+=i;
            }   
            System.out.println(Thread.currentThread().getName() + ", s=" + s);
            s = 0;
        }
    }
}

执行正确 ，以上示例，如果不采用线程同步如何解决？可以让每个线程创建一个对象，这样在堆中就不会出现对象的状态共享了，从而可以避免线程安全问题

线程同步后的状态

这里写图片描述

为每一个线程创建一个对象来解决线程安全问题
    public class ThreadTest13 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            t1.start();
            //再次创建Processor对象，每个线程拥有自己的对象
            Runnable r2 = new Processor();
            Thread t2 = new Thread(r2, "t2");
            t2.start();
        }   
    }
    class Processor implements Runnable {
        //定义成员变量s，作为累加变量    
        private int s = 0;
        public void run() {
            for (int i=0; i<10; i++) {
                s+=i;
            }   
            System.out.println(Thread.currentThread().getName() + ", s=" + s);
            s = 0;
        }
    }

死锁

        synchronized(a){
            ...//1   
          synchronized(b){
           }
        }
        synchronized(b){
            ... //2
          synchronized(a){
           }
        }

解决死锁

  • 一般我们借助于线程的通信解决死锁问题

         synchronized(a){
        ...//1   
      wait();
      synchronized(b){
       }
    }
    synchronized(b){
        ... //2
      synchronized(a){
            notify();
       }
    }

解决死锁的案例

这里写图片描述

线程状态

这里写图片描述

守护线程

  • 从线程分类可以分为：

    • 用户线程(以上讲的都是用户线程)

    • 守护线程。守护线程是这样的，所有的用户线程结束生命周期，守护线程才会结束生命周期，只要有一个用户线程存在，那么守护线程就不会结束，例如java中著名的垃圾回收期就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。

      public class DaemonThreadTest01 {
    public static void main(String[] args) {
        Runnable r1 = new Processor();
        Thread t1 = new Thread(r1, "t1");
        t1.start();

        for (int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName() + ", " + i);
        }

        System.out.println("主线程结束！！！");
    }   
}

class Processor implements Runnable {

    public void run() {
        for (int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName() + ", " + i);
        }   
    }
}

      主线程执行结束了，但用户线程仍然将数据打印出来了

守护（服务线程）线程示例

    public class DaemonThreadTest02 {
        public static void main(String[] args) {
            Runnable r1 = new Processor();
            Thread t1 = new Thread(r1, "t1");
            //将当前线程修改为守护线程，在线程没有启动时可以修改以下参数
            t1.setDaemon(true);
            t1.start();
            for (int i=0; i<10; i++) {
                System.out.println(Thread.currentThread().getName() + ", " + i);
            }
            System.out.println("主线程结束！！！");
        }   
    }
    class Processor implements Runnable {
        public void run() {
            for (int i=0; i<10; i++) {
                System.out.println(Thread.currentThread().getName() + ", " + i);
            }   
        }
    }
苦修的木鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 进程
qq_68656640的博客
09-21 310
1). 预处理(将包含的头文件全部引入 宏定义全部替换 注释全部删除等)2.) 编译(将文本程序转换成汇编程序并检查代码的规范性、是否有语法错误,每个c语言文件都会有一个表格,这个表格中记录了每个函数的名字 以及 参数 和 地址,编译阶段则会将这些表格合在一起,如果函数名重复 但是地址不重复 且 其中一个地址为空 那么会认为不为空的那个地址,就是函数所在的地址,如果两个地址都为空 那么会报错,如果说两个地址都不为空 就是说 有两个相同名的函数 那么也会报错)
JAVA进程和线程详解
YourbelongingsTT的博客
10-11 606
JAVA进程和线程详解 进程和线程  进程      进程就是一个在内存中独立运行的程序，有自己的地址空间。  线程      线程是进程内部单一的一个顺序控制流,是进程的子集。      多线程：顾名思义，一个进程中的多个线程。      线程的开始：当要运行一个程序时，JVM首先会找到main函数，然后从main;函数开始执行（也即是程序从main函数开始运行的）。  创建线程的两种方法：  ...
java进程
08-16 109
13.1 进程的简单描述 * 进程：分配资源最小的单位 * 线程：“同时”去做几件事情 * 进程与线程： * 一个程序一个进程； * 一个进程最少有一个线程 * 并行与并发：cpu-单核、双核、四核、八核 * 并行：真正的"同时" * 并发：不是真正的"同时" * 控制不了并行，一般只说并发：并发量 * 系统：实时-分时-时间轮 ...
JAVA-JVM参数讲解
最新发布
03-04
- **概述**：`jmap`（JVM Memory Map）主要用于获取dump文件（堆转储快照文件），同时也可以获取目标Java进程的内存相关信息，如Java堆各区域的使用情况、堆中对象的统计信息、类加载信息等。 - **基本用法**： - `...
进程-2.e.rar
03-29
当我们谈论“进程-2.e.rar”时，我们可以理解为这是一个与进程管理相关的学习资料，可能包含了关于进程的深入讲解、示例代码或者案例分析。rar文件是一种常见的压缩格式，用于将多个文件或文件夹打包成一个单一的...
java-concurrency编程内部分享.zip_java-concurrency
09-21
1. **线程与进程**：首先，会讲解线程和进程的基本概念，它们的区别和联系。在Java中，线程是执行的最小单元，而进程则是资源分配的基本单位。 2. **Java并发API**：Java提供了丰富的并发API，如`Thread`类、`...
java-RMI技术讲解.doc
05-09
RMI允许Java对象在不同的Java虚拟机之间调用方法，无论是同一台计算机的不同进程，还是分布在广域网络上的不同计算机。这极大地扩展了Java应用程序的可伸缩性和互操作性。 **RMI的基本概念：** 1. **远程方法调用**...
大学课程讲义-Java基础-多线程.pptx
08-14
本章节主要讲解了Java多线程编程的基础知识，包括线程的概念模型、线程的创建和启动、临界资源、对象锁、线程的互斥和同步等内容。 一、线程的概念模型 在Java中，线程是程序中单个顺序的流控制，一个进程中可以...
Java进程
ChenfengZhang的博客
03-22 133
进程
Java-进程
qq_55916894的博客
11-27 494
本文主要介绍进程的相关知识。
Java---进程
qq_45277758的博客
06-09 401
这里写目录标题进程1、进程和程序的区别2、时间片轮转调度3、并发和并行4、内核态与用户态5、进程的状态转换图6、CPU基于寄存器中的数据来执行程序代码 进程 1、进程和程序的区别 1） 程序（静态）：静态硬盘上的一个可执行文件，是永久存在的 进程（动态）：程序运行起来后，就是一个进程（由系统管理起来的），是系统分配资源（CPU资源、内存）的最小单位，存在是暂时的 2）程序+数据+PCB（进程控制块，是进程存在的唯一标识）=进程 3）双击打开某个文件（该文件叫做程序），打开这个文件让程序运行起来就是一个进程
Java进程和线程详解（手把手教学）
热门推荐
Mrkaizi的博客
05-24 1万+
进程和线程的区别 进程和线程的由来 Java进程和线程的关系 我们的一个Java应用程序，启动类启动后。这个应用程序就是一个进程，他会开启一个主线程进行程序的执行，并不知启动一个主线程，其实还有GC线程等很多线程都在运行。 一个进程就是一个JVM，不同的线程在这个进程内运行，各自具有栈、程序计数器、本地方法区，多个线程共享堆空间，1.7版本方法区（包含静态常量池），1.8时元空间直接放在内存上了 线程的RUN和START方法 run方法是当前主线程通过执行一个方法，执行结束就结束了， start方法是真正
java创建进程
Java
06-06 1639
Java创建进程 1 进程的概念 1 1.1 进程的概念 1 1.2 进程的特征 1 1.3 进程与线程区别 1 2 进程的创建 1 2.1 JAVA进程的创建 1 2.1.1 ProcessBuilder 2 2.1.2 Runtime 3 2.1.3 Process 4 2.2 实例 5 2.2.1 创建子进程 5 2.2.2 进程阻塞问题 7 2.2.3 在...
Java创建进程
xinyuan的专栏
02-16 2194
Java创建进程
java中进程_Java程序-进程中的"进程"
weixin_39994627的博客
02-13 93
进程我们知道程序在磁盘上的时候是静态的，当他被加载到内存的时候，就变成了一个动态的，称为进程，如下图是程序被加载到内存后，在内存中的分布情况如下此图来自http://blog.csdn.net/woshinia/article/details/41722085具体每段的作用可以参考这篇文章，这里我们只要大概了解一下，在程序被加载到内存后，会被分为代码段，数据段，堆段和栈段。其中代码段就是存放数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苦修的木鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值