专栏首页泰斗贤若如线程学习笔记

线程学习笔记

一、进程和线程的概述

1、要想了解多线程,必须先了解线程,而要想了解线程,必须先了解进程,因为线程是依赖于进程而存在

2、什么是进程?

通过任务管理器我们就看到了进程的存在。 而通过观察,我们发现只有运行的程序才会出现进程。       进程:就是正在运行的程序。       进程:是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。

3、多进程有什么意义呢?

单进程的计算机只能做一件事情,而我们现在的计算机都可以做多件事情。

      举例:一边玩游戏(游戏进程),一边听音乐(音乐进程)。 也就是说现在的计算机都是支持多进程的,可以在一个时间段内执行多个程序。 可以提高CPU的使用率。

      问题: 一边玩游戏,一边听音乐是同时进行的吗?

                  不是。因为单核CPU在某一个时间点上只能做一件事情。 而我们在玩游戏,和在听音乐的时候,是CPU在做着程序间的高效切换让我们觉得是同时进行的。

4、什么是线程?

  在同一个进程(正在运行的程序)内又可以执行多个任务,而这每一个任务我就可以看出是一个线程。       线程:是程序的执行单元,执行路径。是程序使用CPU的最基本单位。       单线程:如果程序只有一条执行路径。

      多线程:如果程序有多条执行路径。 一个进程 = 一个正在运行的程序 = 1个线程+1个线程+1个线程+... = 多个线程 = 多个任务

5、多线程有什么意义呢?

  多线程的存在,不是提高程序的执行速度。其实是为了提高应用程序的使用率(提高能使用cpu的概率)。 程序的执行其实都是在抢CPU的资源,或者叫CPU的执行权。 多个进程是在抢这个资源,而其中的某一个进程如果执行路径(线程)比较多,那么就会有更高的几率抢到CPU的执行权。 我们是不敢保证哪一个线程能够在哪个时刻抢到cpu的执行权的,所以线程的执行具有随机性小结: 多进程的意义:提高使用cpu的效率。(多用cpu) 多线程的意义:提高能使用cpu的概率。(有多少机会用cpu,因为cpu不是你想用就能用啊)

多线程程序的引入图解

二、Java程序的运行原理及JVM的启动是多线程的吗?

A:Java程序的运行原理 Java通过java命令会启动java虚拟机。启动JVM,等于启动了一个应用程序,也就是启动了一个进程。      该进程会自动启动一个 “主线程” ,然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。 B:JVM的启动是多线程的吗?  垃圾回收线程也要先启动,否则很容易会出现内存溢出。      JVM的启动是多线程的,因为它最低有两个线程启动了,主线程垃圾回收线程

示例代码如下:

1 package cn.itcast_01;
 2 /*
 3  *    进程:
 4  *        正在运行的程序,是系统进行资源分配和调用的独立单位。
 5  *        每一个进程都有它自己的内存空间和系统资源。
 6  *    线程:
 7  *        是进程中的单个顺序控制流,是一条执行路径。
 8  *        是程序的执行单元,执行路径。是程序使用CPU的最基本单位。
 9  *
10  *        一个进程如果只有一条执行路径,则称为单线程程序。
11  *        一个进程如果有多条执行路径,则称为多线程程序。
12  *
13  *  举例:
14  *      扫雷程序,迅雷下载
15  *  
16  *  大家注意两个词汇的区别:并行和并发。
17  *        并行:前者是逻辑上同时发生,指在某一个时间内同时运行多个程序。
18  *        并发:后者是物理上同时发生,指在某一个时间点同时运行多个程序。
19  *
20  *      
21  *
22  * Java程序的运行原理:
23  *        通过java命令会启动 java虚拟机。启动 JVM,等于启动了一个应用程序,也就是启动了一个进程。
24  *        该进程会自动启动一个 “主线程”,然后主线程去调用某个类的 main方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。
25  * 
26  * 思考题:
27  *         jvm虚拟机的启动是单线程的还是多线程的?
28  *             多线程的。
29  *             原因是垃圾回收线程也要先启动,否则很容易会出现内存溢出。
30  *             现在的垃圾回收线程加上前面的主线程,最低启动了两个线程,所以,jvm的启动其实是多线程的。
31  */
32 public class MyThreadDemo {
33     public static void main(String[] args) {
34         System.out.println("hello");
35         new Object(); // 造对象
36         new Object(); // 造对象
37         new Object(); // 造对象
38         new Object(); // 造对象
39         //...造很多很多对象后,如果垃圾回收线程不启动的话,内存就会溢出!
40         System.out.println("world");
41     }
42 }

3、多线程的实现方案(掌握)

A:自定义类继承Thread类

1:自定义类MyThread继承Thread类

2:MyThread类里面重写run()方法

3:在测测试类MyThreadTest中创建MyThread类的对象

4:启动线程

代码演示:

package com.thread;

public class ThreadDemo extends Thread {
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"执行了"+i+"次");
        }
    }
}
class Test{
    public static void main(String[] args) {
        ThreadDemo thread = new ThreadDemo();
        thread.start();
    }
}

运行结果:

Thread-0执行了0次
Thread-0执行了1次
Thread-0执行了2次
Thread-0执行了3次
Thread-0执行了4次
Thread-0执行了5次
Thread-0执行了6次
Thread-0执行了7次
Thread-0执行了8次
Thread-0执行了9次

B:自定义类实现Runnable接口

1:自定义类MyRunnable实现Runnable接口

2:MyRunnable类里面重写run()方法

3:在测测试类MyRunnableTest中创建MyRunnable类的对象

4;在测测试类MyRunnableTest中再创建Thread类的对象,并把3步骤的对象作为构造参数进行传递

5:启动线程

 代码演示:

package com.thread;

public class Runable1 implements Runnable{
    
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"执行了"+i+"次");
        }
    }
}
class Runnable1Demo {
    public Runnable1Demo() {
    }

    public static void main(String[] args) {
        Runable1 runable1 = new Runable1();
        Thread thread = new Thread(runable1);
        Thread thread1 = new Thread(runable1);

        thread.start();
        thread1.start();
    }
}

  运行结果:

Thread-0执行了0次
Thread-1执行了0次
Thread-0执行了1次
Thread-1执行了1次
Thread-0执行了2次
Thread-1执行了2次
Thread-0执行了3次
Thread-1执行了3次
Thread-0执行了4次
Thread-1执行了4次
注意事项:
    1:Thread类的方法:
        public final String getName() 获取线程对象的名称(一般放在需要被线程执行的代run()方法里面)
        public final void setName(String name) 设置线程对象的名称
        对象名.setName("林青霞");
                    
    2:在不是Thread类的子类中,如何获取线程对象的名称呢?
        public static Thread currentThread() 返回当前正在执行的线程对象(静态方法)
        Thread.currentThread().getName()
            
    3:该自定义的类为什么要重写run()方法?
        自定义类中不是所有的代码都需要被线程执行。
        而这个时候,为了区分哪些代码能够被线程执行,java提供了Thread类中的run()方法,用来包含那些需要被线程执行的代码。    
        注意:这里的  被线程执行 = 开一个新线程执行    
            
    4:由于自定义类实现了接口,所以就不能在自定义类中直接使用Thread类的getName()方法了,但是可以间接的使用。
        Thread.currentThread().getName()

   5:为什么要实现Runnable接口?
       -Java不支持多继承
          -不打算重写Thread类的其他方法
小问题:
    1:为什么要重写run()方法?
        答:run()方法里面封装的是被线程执行的代码。    
    2:启动线程对象用的是哪个方法?
        答:start()方法
    3:run()方法和start()方法的区别?
        答:run()方法直接调用仅仅是普通方法。
           start()方法是先启动线程,再由jvm去调用run()方法。
    4:有了方式1,为什么还来一个方式2呢?
        答:若自定义类MyThread类已经有一个父类了,那么它就不可以再去继承Thread类了。(java不支持多继承)
           若自定义类MyRunnable类已经实现了一个接口了,那么它还可以再去实现Runnable接口。(java支持多实现)
           即可以避免由于Java单继承带来的局限性。
            
           在测试类MyThreadTest中,要想开多个线程,就要先new多个自定义类MyThread的对象,每一个自定义类MyThread的对象的成员变量都相同,这样需要在栈中开辟很多内存;
           在测试类MyRunnableTest中,要想开多个线程,只需要new一个自定义类MyRunnable的对象,再new多个Thread类的对象即可,这样就大大节约了内存。
           即适合多个相同程序的代码去处理同一个资源的情况,把线程同程序的代码和数据有效分离(即耦合性降低),较好的体现了Java面向对象的设计思想。

4、线程的调度模型和如何获取和设置线程优先级

      假如我们的计算机只有一个CPU,那么CPU在某一个时刻只能执行一条指令,线程只有得到CPU时间片,也就是使用权,才可以执行指令。 那么Java是如何对线程进行调用的呢?

线程有两种调度模型。

A:线程的调度模型

        a:分时调度模型 所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片。

        b:抢占式调度模型 (Java采用的是该调度方式) 优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的CPU时间片的概率相对高一些。

B:如何获取和设置线程优先级

         线程默认的优先级是:5。

         线程优先级的范围是:1-10。

如何获取线程对象的优先级?

         public final int getPriority()

         返回线程对象的优先级 int i = 对象名.getPriority();

如何设置线程对象的优先级?

         public final void setPriority(int newPriority) 更改线程的优先级 对象名.setPriority(10); IllegalArgumentException:非法参数异常 抛出的异常表明向方法传递了一个不合法或不正确的参数。

5、线程的控制(即线程常见的方法)

A:线程休眠

     public static void sleep(long millis)    单位是毫秒(该方法会抛出异常)
     Thread.sleep(1000);
package com.thread;

public class Sleep implements Runnable{
   
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            if (i==5){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"执行了"+i+"次");
        }
   }
}
class SleepDemo {
    public SleepDemo() {
    }

    public static void main(String[] args) {
        Sleep sleep = new Sleep();
        Thread thread = new Thread(sleep);
        thread.start();

    }
}
B:线程加入
     public final void join()     等待该线程终止(为了使某线程先执行完毕)(该方法会抛出异常)
     对象名.join(); // 该方法必须在启动线程后调用
package com.join;

public class MyThread extends Thread{

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            System.out.println(this.getName()+"执行了"+i+"次");
        }
    }
}
class JoinDemo {
   
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();

        try {
            myThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i=0;i<5;i++){
            System.out.println("主线程执行了"+i+"次");
        }

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

  运行结果:

Thread-0执行了0次
Thread-0执行了1次
Thread-0执行了2次
Thread-0执行了3次
Thread-0执行了4次
Thread-0执行了5次
Thread-0执行了6次
Thread-0执行了7次
Thread-0执行了8次
Thread-0执行了9次
主线程执行了0次
主线程执行了1次
主线程执行了2次
主线程执行了3次
主线程执行了4次
主线程执行结束
C:线程礼让
     public static void yield() 暂停当前正在执行的线程对象,并执行其他线程。 能够在一定的程度上,让多个线程的执行更和谐,但是不能靠它保证一个线程一次。
     Thread.yield();
                
D:后台线程(守护线程/用户线程)
     public final void setDaemon(boolean on)     将该线程标记为守护线程或用户线程
     对象名.setDaemon(true); // 设置守护线程
     当正在运行的线程都是守护线程时,Java虚拟机退出。该方法必须在启动线程前调用。
                
E:中断(终止)线程(掌握)
     public final void stop()     让线程停止,过时了,但是还可以使用。(为什么会过时呢?因为该方法太暴力了,具有固有的不安全性,直接把线程停止,该线程之后的代码都不能执行了)
     对象名.stop();
     public void interrupt()     中断线程。 把线程的状态终止,并抛出一个InterruptedException异常。
     对象名.interrupt();
                
        注意事项:
            如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws。

6、线程的状态和生命周期

A:线程的创建 创建线程对象,无资格无权。

B:线程的就绪 有资格无权

C:线程的运行 有资格有权

D:线程的阻塞 无资格无权

E:线程的死亡 无资格无权

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 小游戏——金庸奇侠传(JAVA,对面向对象的进一步了解)

    泰斗贤若如
  • Java匹马行天下之JavaSE核心技术——面向对象

    Java中可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

    泰斗贤若如
  • Java匹马行天下之JavaSE核心技术——面向对象

                      如下例所示,static修饰符用来创建类方法和类变量:

    泰斗贤若如
  • (65) 线程的基本概念 / 计算机程序的思维逻辑

    在之前的章节中,我们都是假设程序中只有一条执行流,程序从main方法的第一条语句逐条执行直到结束。从本节开始,我们讨论并发,在程序中创建线程来启动多条执行流,并...

    swiftma
  • Java之线程,常用方法,线程同步,死锁

    1, 线程的概念 进程与线程 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程。(进程是资源分配的最...

    二十三年蝉
  • Java多线程详解

    每个运行的程序就是一个进程,当一个程序运行时,内部可能包含了多个顺序执行流,每个顺序执行流就是一个进程。

    二十三年蝉
  • 【J2SE快速进阶】——Java多线程机制

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/huyuyang6688/article/...

    DannyHoo
  • java 主线程等待子线程执行完后再执行

    示例如下,我们初始化一个CountDownLatch,值为10(子线程个数),然后每次一个子线程执行完后执行一下countDown(),代码示例如下:

    IT云清
  • bat等大公司常考多线程面试题【力荐】

    思考题:希望大家积极的思考,并且可以踊跃的说出自己的想法,想法不管对与错,只要说出来就是一种提高,所以,希望小伙伴们可以把自己的想法在留言区给出,这样大家也可以...

    好好学java
  • 1.有关线程、并发的基本概念

    什么是线程?   提到“线程”总免不了要和“进程”做比较,而我认为在Java并发编程中混淆的不是“线程”和“进程”的区别,而是“任务(Task)”。进程是表示资...

    用户1148394

作者介绍

精选专题

活动推荐

扫码关注云+社区

领取腾讯云代金券