Java学习笔记（多线程_1）

最新推荐文章于 2023-01-31 14:25:28 发布
最新推荐文章于 2023-01-31 14:25:28 发布
阅读量324 收藏
点赞数
分类专栏： Java基础学习 文章标签： java 多线程 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g234872714f/article/details/50059809
版权

15 多线程

15.1 概念

进程：正在进行中的程序；每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

线程：进程中负责程序执行的控制单元（执行路径），线程在控制着进程的执行。

  1. 一个进程中至少有一个线程；
  2. 一个进程中可以由多个执行路径，称为多线程；
  3. 开启多线程是为了同时运行多部分代码，每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

15.2 创建线程的方法

15.2.1 方法一：继承Thread类

通过对api的查找，java已经提供了对线程这类事物的描述，即Thread类。

  1. 定义类继承Thread；
  2. 重写Thread类中的run方法；目的：将自定义的方法存储在线程中，让线程运行；
  3. 调用线程的start方法，该方法两个作用：启动线程和调用run方法；

例1

class Demo extends Thread{
    public void run(){
        for(int x =0;x<6;x++){
            System.out.println("demo run"+x);
        }
    }
}
public class ThreadDemo {

    public static void main(String[] args) {
            Demo d = new Demo();//创建了一个线程
            d.start();//开启线程并执行该线程的run方法
            //d.run();//仅仅对象调用方法，而线程创建了并未运行。
            for(int x =0;x<5;x++){
                System.out.println("Hello"+x);
            }
    }

}

运行结果：

创建线程的目的就是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行，而运行的指定代码就是这个执行路径的任务。

为何要重写run方法：
Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

多线程运行状态：

例2

class Demo extends Thread{
    Demo(String name){
        super(name);
    }

    public void run(){
        for(int x =0;x<6;x++){
            System.out.println((Thread.currentThread()==this)+"..."+this.getName()+".run.."+x);
        }
    }
}
public class ThreadDemo {

    public static void main(String[] args) {
            Demo d = new Demo("one");//创建了一个线程
            Demo d1= new Demo("two");
            d.start();
            d1.start();

            for(int x =0;x<5;x++){
                System.out.println("Hello"+x);
            }
    }

}

PS：
1. 可通过Thread的getName()方法获取线程的名称，名称格式如下：Thread-编号（0开始）；
2. Thread创建时就已经命名了；
3. currentThread();获取当前线程对象；
4. 设置线程名称：setName或者构造函数。

15.2.2 方法二：实现Runnable接口

步骤：

  1. 定义类 Runnable接口；
  2. 重写Runnable接口中的run方法；将线程要运行的代码放在该run方法中；
  3. 通过Thread类建立线程对象；
  4. 将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数；
  5. 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

例3

class Ticket1 implements Runnable{
    private int tick = 8;
    public void run(){
        while(true){
            if(tick>0)
                System.out.println(Thread.currentThread().getName()+
                        "...sale.."+tick--);
        }
    }   
}

public class TicketDemo {

    public static void main(String[] args) {
        Ticket1 t = new Ticket1();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

实现方式和继承方式的区别：

  1. 实现Runnable接口避免了单继承的局限性，在定义线程时，建议使用实现方式；
  2. 继承Thread，线程代码存放在Thread子类run方法中；实现Runnable，线程代码存在接口的子类run方法中。
15.2.3 线程安全

代码：

class Ticket1 implements Runnable{
    private int tick = 10;
    public void run(){
        while(true){
            if(tick>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+
                        "...sale.."+tick--);
            }
        }
    }
}

public class TicketDemo {

    public static void main(String[] args) {
        Ticket1 t = new Ticket1();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：
打印出tick小于等于0的结果，

问题原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

采用同步代码块：

synchronized(对象){
    需要被同步的代码；
}

对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权也进不去，因为没有获取锁。

使用前提必须有多个线程并使用同一个锁。

修改后的代码：

class Ticket1 implements Runnable{
    private int tick = 10;
    Object obj = new Object();
    public void run(){
        while(true){
            synchronized(obj){
                if(tick>0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+
                            "...sale.."+tick--);
                }
            }
        }
    }
}

public class TicketDemo {

    public static void main(String[] args) {
        Ticket1 t = new Ticket1();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);

        t1.start();
        t2.start();
        t3.start();
    }
}

同步代码块的弊端：多个线程需要判断锁，较为消耗资源，会降低程
序的运行效率。

如何找问题：

  1. 明确哪些代码是多线程运行代码；
  2. 明确共享数据；
  3. 明确多线程运行代码中哪些语句是操作共享数据的。

例4：

class Bank{
    private int sum;
    public void add(int n){
        sum += n;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sum="+sum);
    }
}

class Cus implements Runnable{
    private Bank b = new Bank();

    public void run() {
        for(int x=0;x<3;x++){
            b.add(100);
        }
    }   
}

public class BankDemo {
    public static void main(String[] args) {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(c);
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：

修改后：

class Bank{
    private int sum;
    Object obj = new Object();
    public synchronized void add(int n){//同步函数
        //synchronized(obj){
            sum += n;
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sum="+sum);
        //}
    }
}

class Cus implements Runnable{
    private Bank b = new Bank();

    public void run() {
        for(int x=0;x<3;x++){
            b.add(100);
        }
    }   
}

public class BankDemo {
    public static void main(String[] args) {
        Cus c = new Cus();
        Thread t1 = new Thread(c);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(c);
        t1.start();
        t2.start();
        t3.start();
    }
}

同步的两种表现形式：同步代码块和同步函数。

Ps:
1. 同步函数的锁是固定的this；
2. 同步代码块的锁是任意的对象。

由于同步函数的锁是固定的this，同步代码块是锁的任意的对象，如果同步函数和同步代码块都使用this作为锁，就可以实现同步。

class Ticket implements Runnable{
    private int tick = 10;
    boolean flag = true;

    //Object obj = new Object();
    public void run(){
        if(flag){
            while(true){
                synchronized(this){
                    if(tick>0){
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+
                                "...code.."+tick--);
                    }
                }
            }
        }else{
            while(true)
                show();
        }
    }

    public synchronized void show(){
        if(tick>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+
                    "..function.."+tick--);
        }
    }
}

public class TicketDemo {
    public static void main(String[] args) {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);

        t1.start();
        try {
            Thread.sleep(10);//线程休眠目的是为了使t1真正启动后，flag才设置为false；
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.flag=false;
        t2.start();
    }
}

运行结果：

如果同步函数被静态修饰后，使用的锁不是this，而是该函数所属字节码文件对象，可以用getClass方法获取，也可以用当前类名.class表示。

class Ticket implements Runnable{
    private static int tick = 10;
    boolean flag = true;
    public void run(){
        if(flag){
            while(true){
                synchronized(Ticket.class){//this.getClass()
                    if(tick>0){
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+
                                "...code.."+tick--);
                    }
                }
            }
        }else{
            while(true)
                show();
        }
    }

    public static synchronized void show(){
        if(tick>0){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+
                    "..function.."+tick--);
        }
    }
}

public class TicketDemo {
    public static void main(String[] args) {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);

        t1.start();
        try {
            Thread.sleep(10);//线程休眠目的是为了使t1真正启动后，flag才设置为false；
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.flag=false;
        t2.start();
    }
}
15.2.4 多线程中单例模式

1. 饿汉式

class Single{
    private static final Single s = new Single();
    private Single(){}
    public static Single getInstance(){
        return s;
    }
}

饿汉式不存在安全问题，因为不存在多个线程共同操作数据的情况。

2. 懒汉式

class Single{
    private static Single s = null;
    private Single(){}

    public static Single getInstance(){
        if(s==null){
            synchronized(Single.class){
                if(s==null)
                    s =new Single();
            }
        }
        return s;
    }
}

懒汉式存在安全问题，可以使用同步函数解决。

方式一：

    public static synchronized Single getInstance(){
        if(s==null)
            s =new Single();
        return s;
    }

该方式使用效率较低，每次均需要判断；

方法二：

public static Single getInstance(){
    if(s==null){
        synchronized(Single.class){
            if(s==null)
                s =new Single();
        }
    }
    return s;
}

原因在于任何一个线程在执行到第一个if判断语句时，如果Single对象已经创建，则直接获取即可，而不用判断是否能够获取锁，相对于上面使用同步函数的方法就提升了效率。如果当前线程发现Single对象尚未创建，则
再判断是否能够获取锁。

  1. 对于单例而言，只有一个对象，因此如果对象已经创建则可直接获取；
  2. 如果没有对象，则进行判断获取锁，
  3. 如果能够获取锁，那么就通过第二个if判断语句判断是否需要创建Single对象。因为可能当此线程获取到锁之前，已经有一个线程创建完Single对象，并且放弃了锁。此时它便没有必要再去创建，可以直接跳出同步代码块，放弃锁，获取Single对象即可。如果有必要，则再创建。
  4. 如果不能获取到锁，则等待，直至能够获取到锁为止，再按步骤一执行。
15.2.5 死锁

同步嵌套的死锁
class Ticket implements Runnable{
private static int tick = 10;
boolean flag = true;
Object obj = new Object();

    public void run(){
        if(flag){
            while(true){
                synchronized(obj){//this.getClass()
                    show();
                }
            }
        }else{
            while(true)
                show();
        }
    }

    public synchronized void show(){
        synchronized(obj){
            if(tick>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+
                        "..function.."+tick--);
            }
        }
    }
}

public class TicketDemo {
    public static void main(String[] args) {
        Ticket t = new Ticket();

        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);

        t1.start();
        try {
            Thread.sleep(10);//线程休眠目的是为了使t1真正启动后，flag才设置为false；
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.flag=false;
        t2.start();
    }
}
壶里先森
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程笔记_java/多线程_
10-03
对多线程进行全面学习的笔记，里面包含简单到复杂的多线程的基础知识
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 862
文章标题
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3171
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java学习笔记-多线程
cyh0503的博客
07-08 2743
并发与并行 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多...
Java多线程学习笔记 - 1
涞公子的博客
03-13 2402
多任务 概述： 多任务就是同时运行多个任务。 好处： 充分利用了CPU的资源，提高了代码的执行效率。 执行方式： 并发：在一段时间内交替去执行多项任务【任务数 > 核数】 并行：多个计算机内核一起执行任务，一个内核负责执行一个任务【任务数 <= 核数】 实现方式： 多线程或多进程。 进程与线程介绍： 进程 概述： 线程 概述： 进程与线程之间的关系 一个进程内含有一个或多个线程，但至少含有一个线程。 ...
Java多线程笔记详解
you are sherlocked by me!
10-09 533
这是学习多线程知识的学习笔记，大家可以选择自己感兴趣的部分阅读学习 详细代码见github代码   Java多线程学习笔记1之多线程基础 内容: 1) 基本概念以及线程的实现方法   Java多线程学习笔记2之多线程基础 内容: 1) 数据同步 2) 非线程安全情况以及处理方法 3) Java内存模型 4) Thread.currentThread()抽象方法使用 ...
《Java多线程编程核心技术》学习笔记（1）
热门推荐
洋YANG的博客
02-23 1万+
一、实现多线程的编程方式 （1）继承Thread类 public class MyThread extends Thread { @Override public void run() { super.run(); System.out.println(&amp;amp;amp;amp;quot;MyThread&amp;amp;amp;amp;quot;); } } public class Run { publi
Java 学习多线程笔记
cyberscutoid的博客
03-07 2180
多线程的目的 为了更合理的利用cpu资源 多线程的概念 一个进程运行时产生多个线程 并行与并发 并行：多个cpu实例同时执行一段逻辑 并发：通过cpu调度算法，让程序看上去像是同时执行，提高程序运行效率。 线程安全 线程安全：在并发的前提下，该代码经过多线程的使用，线程的调度顺序不影响产生的结果。 线程不安全：与线程安全相反，线程的调度顺序影响最终的结果 同步：通过人为的控制与调度，保证共享资源的多线程访问成为线程安全，确保结果的准确。 调度：1.分时 2.抢占
Java学习笔记
PaulHoldOn的博客
01-31 1524
Java
JAVA多线程学习
HBlock的博客
08-01 1357
一、线程与进程1、线程：程序中单独顺序的控制流 线程本身是依靠程序进行运行，线程是程序中的顺序控制流，只能使用分配给程序的资源和环境。 2、进程：执行中的程序 一个进程可以包含一个或多个线程，即至少包含一个线程。 3、单线程：程序中只存在一个线程，实际上主方法(main函数)就是一个主线程。 4、多线程：多线程是在一个程序中运行多个任务，其目的是更好的使用CPU资源。二、线程的实现1、JA
多线程学习笔记05线程协作
asdfghjkl_zth的博客
02-01 2524
文章目录多线程学习笔记05线程协作线程通信解决方式1管程法解决方式2信号灯法 多线程学习笔记05线程协作 线程通信 应用场景：生产者和消费者问题 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费； 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止； 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。 我们来分析一下： 首先，这是一个线程同步问题，生产者和消费者共享同一个资
java学习笔记_多线程.txt
09-29
java学习笔记_多线程.txt，包括死锁的原因和解锁的方法。
java基础代码_java_输入输出流_接口_多线程_异常_
09-29
在校学习时编写的java代码以及思考笔记，涉及java多线程的实现与协调、输入输出流、接口、继承等内容，适合java新手编程入门
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
学习目录：1. 线程简介 2. 线程实现（重点） 3. 线程状态 4. 线程同步（重点） 5. 线程通信问题 6. 高级主题
多线程-狂神说Java学习笔记
07-19
狂神说Java学习笔记（笔记+源代码+图片)—多线程
Java学习笔记（反射+枚举类）
g234872714f的博客
03-15 3424
19 反射 19.1 类的加载概述和加载时机 19.1.1 类的加载概述 当程序要使用某个类时，如果该类还未加载到内存中，则系统会通过加载、连接、初始化三步来实现对这个类进行初始化。 加载： 指将class文件读入内存中，并为之创建一个Class对象，任何类被使用时系统都会建立一个Class对象。 连接： 验证：是否有正确的内部结构，并和其他类协调一致 准备：负责为类的静态成
Java学习笔记（注释、对象初始化过程、单例模式）
g234872714f的博客
11-15 1249
面向对象9.帮助文档的制作9.1注释- 原则： 1、注释形式统一 在整个应用程序中，使用具有一致的标点和结构的样式来构造注释。如果在其它项目中发现它们的注释规范与这份文档不同，按照这份规范写代码，不要试图在既成的规范系统中引入新的规范。 2、注释内容准确简洁 内容要简单、明了、含义准确，防止注释的多义性，错误的注释不但无益反而有害。 - 注释格式：　1. 单行(si
Java学习笔记（网络编程）
g234872714f的博客
03-27 962
21 网络编程21.1 网络参考模型 找到对方IP； 数据要发送到对方指定的应用程序上，为标识这些应用程序，故应用数字进行标识，称为端口，逻辑端口； 定义通信规则，称为协议，国际组织定义了通用协议TCP/IP。 OSI（Open System Interconnection 开放系统互连）参考模型TCP/IP 参考模型七层描述 物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输
Java学习笔记（面向对象1）
g234872714f的博客
11-14 442
面向对象1.何为面向对象 面相对象是相对面向过程而言的 面相对象和面向过程都是一种思想 面向过程 强调功能行为 面向对象 将功能封装进对象，强调具备了功能的对象。 面向对象是基于面向过程的。 2.类与对象 类就是对现实生活中事物的描述； 对象则是这类事物，实实在在存在的个体； 描述类时，有属性（成员变量）和行为（成员方法）； 成员变量与局部变量 成员变量作用于整个类中； 局部变量作用于函数中或
java完整学习笔记
最新发布
02-27
下面是Java学习的一些重要知识点和学习笔记： 1. Java基础： - 数据类型：Java提供了多种数据类型，包括基本数据类型和引用数据类型。 - 控制流程：学习如何使用条件语句（if-else、switch）、循环语句（for、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值