多线程的实现与安全问题

最新推荐文章于 2023-05-02 14:48:32 发布
最新推荐文章于 2023-05-02 14:48:32 发布
阅读量202 收藏
点赞数
分类专栏： JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52858666/article/details/127306521
版权

线程与进程

线程是什么？

  1. 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程
  2. 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程

进程是什么？

​ 指一个内存中运行的应用程序，每个进程都有一个独立的内存空间

线程调度

分时调度

​ 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间

抢占式调度

  1. 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java中默认使用的为抢占式调度
  2. CPU使用抢占式调度模式在多个线程间进行着告诉的切换。对于CPU的一个核心而言，只能够执行一个线程，而CPU的在多个线程间切换速度相对于我们的感觉要快很多，看上去就是在同一时刻运行。实际上，多线程程序并不能提高程序的运行速度，但是能够提高程序运行效率，让CPU的使用率更高。

同步与异步

同步：排队执行，效率低但安全。

异步：同时执行，效率高但不安全。

并发与并行

并发：指两个或多个事件在同一个时间段内发生

​ 比如：一秒内的完成了5000次下单

并行：指两个或多个事件在同一个时刻发生(同时发生)

​ 比如：在同一时刻打印了两句话

线程的创建方式

  1. 继承Thread类
  2. 实现Runnable类

继承Thread类方式

实现步骤：

  1. 创建一个类
  2. 继承Thread类
  3. 重写run()方法

代码实现

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

注意点：

​ 开启线程是调用start()方法，而不是直接调用run方法

实现Runnable接口方式

实现步骤：

  1. 创建一个类实现Runnable接口
  2. 实现run()方法

代码

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class Test {

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

Thread类常用方法

  • public static Thread currentThread()

    返回当前正在执行的线程对象的引用，返回的是一个Thread类型

  • public String getName()

    返回当前线程的名称

  • public void interrupt()

    中断线程：如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，并抛出 nterruptedException异常。

  • public static void sleep(long millis)

    在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。

  • publilc void setDaemon(boolean on)

    将该线程标记为守护线程或用户线程。

  • public void setName(String name)

    改变线程名称，使之与参数 name 相同。

  • public void setPriority(int newPriority)

    更改线程的优先级。

    优先级在1-10之间 MIN_PRIORITY：1 MAX_PRIORITY：10

线程安全问题

当两个或两个以上的线程去操作同一个变量时，就会出现不安全的问题

问题描述：

​ 现在有A、B两个线程、变量num=100，当A线程拿到了num，并且此时num=100，但是这个时候，B线程来了，同时也拿到了num，此时num=100，但是B线程抢先一步A线程把num变成了99，而A拿到的num仍然是100，这个时候A拿这个值为100的num去操作就会出现数据不安全的问题，因为这个时候num应该为99，A线程应该拿num=99这个值取进行别的操作。

  • 演示问题
public class SynchronizedDemo {

    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        new Thread(ticket).start();
        new Thread(ticket).start();
        new Thread(ticket).start();

    }
}

public class Ticket implements Runnable{

    public int num = 100;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (num>0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num--;
                System.out.println("剩余票数："+num);
            }
        }
    }
}
  • 运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GxEOZzrq-1665656449414)(assets/image-20211120163717655.png)]

结果：出现重复值，理论上每个值都只出现一次，并且当票数等于0时，就不再继续打印

解决方法

  1. 同步代码块
  2. 同步方法
  3. 同步锁Lock
同步代码块

代码实现

public class Ticket implements Runnable{

    /**
     * 现在有一百张车票
     */
    public int num = 100;

    @Override
    public void run() {
            for (int i = 0; i < 100; i++) {
                //在此添加
                synchronized (this) {
                    if (num>0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    num--;
                    System.out.println(Thread.currentThread().getName()+"线程卖出一张票，剩余票数："+num);
                }
            }
        }
    }
}
  • 运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qw2WoO1f-1665656449415)(assets/image-20211120164234845.png)]

发现没有重复被消费的问题

同步方法

在需要的方法上加synchronized修饰符即可

此处需要新建一个sale()方法，在此方法上加synchronized

如果在run在加那么整个卖票操作就会被一个线程执行完，无法起到多条线程同时出售的效果

public class Ticket implements Runnable{

    public int num = 100;

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sale();
        }
    }

    public synchronized void sale(){
        if (num>0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"线程正在卖票，剩余票数："+num);
        }
    }
}
同步锁Lock

此处为了规范，加入了try catch代码块，lock.lock()方法之后紧跟try代码块，lock.unlock()在finally中释放

获取Lock的方法，Lock lock = new ReentrantLock();

lock.lock()表示上锁

lock.unlock()表示释放锁

public class Ticket implements Runnable{

    public int num = 100;

    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sale();
        }
    }

    public void sale(){
        lock.lock();
        try {
            if (num>0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                num--;
                System.out.println(Thread.currentThread().getName()+"线程正在卖票，剩余票数："+num);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

公平锁与非公平锁

  • 公平锁

    依次排队执行，先到先得

    实现方式:创建Lock时添加参数true

    ​ Lock lock = new ReentrantLock(true);

  • 非公平锁

    谁抢到谁就先执行，以上的三种解决安全问题的方法都是非公平锁

线程死锁

假如有A、B两个线程，线程A需要等待线程B回应才可执行，线程B也要等线程A回应才可执行，此时就僵持住了，也就造成了线程死锁

解决方式：不要使用可以带锁的线程，去调用另一个会带锁的线程

多线程通信问题

生产者与消费者案例

需求：生产者生产一份食物，消费者就消费一份食物。生产者生产时，消费者不能消费。消费者需要等生产者生产完毕之后才能消费。

有问题的代码

public class Demo {
    public static void main(String[] args) {
        Food food = new Food();
        new Consumer(food).start();
        new Product(food).start();
    }
    static class Consumer extends Thread{
        private Food food;
        public Consumer(Food food) {
            this.food=food;
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                food.get();
            }
        }
    }
    static class Product extends Thread{
        private Food food;
        public Product(Food food) {
            this.food=food;
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if (i%2==0) {
                    food.setNameAndTaste("小鸡炖蘑菇","甜甜");
                } else {
                    food.setNameAndTaste("镇江牛肉面","香辣");
                }
            }
        }
    }
    static class Food{
        private String name;
        private String taste;
        public void setNameAndTaste(String name,String taste){
            this.name=name;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.taste=taste;
        }
        public void get(){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("消费者消费了："+name+",味道为："+taste);
        }
    }
}
  • 运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5bX1Mbkm-1665656449416)(assets/image-20211120172029382.png)]

问题描述：

​ 这种方式导致了生产时没生产完成，消费者就消费了。

​ 即生产小鸡炖蘑菇时，上一份的镇江牛肉面还没生产完成，此时菜名name=“小鸡炖蘑菇”，味道taste=“香辣”，在这个瞬间，去调用get方法，就会出现以上运行的情况

解决了问题的代码

public class Demo {
    public static void main(String[] args) {
        Food food = new Food();
        new Consumer(food).start();
        new Product(food).start();
    }
    static class Consumer extends Thread{
        private Food food;
        public Consumer(Food food) {
            this.food=food;
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                food.get();
            }
        }
    }
    static class Product extends Thread{
        private Food food;
        public Product(Food food) {
            this.food=food;
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if (i%2==0) {
                    food.setNameAndTaste("小鸡炖蘑菇","甜甜");
                } else {
                    food.setNameAndTaste("镇江牛肉面","香辣");
                }
            }
        }
    }
    static class Food{
        private String name;
        private String taste;
        //表示此时生产者可以生产
        private boolean flag=true;
        public synchronized void setNameAndTaste(String name,String taste) {
            //判断是否可生产
            if (flag) {
                this.name=name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste=taste;
                //此时已有产品，生产者不可生产
                flag = false;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        public synchronized void get(){
            //判断是否可消费，生产者不可生产时消费则就可以消费
            if (!flag) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消费者消费了："+name+",味道为："+taste);
                //此时产品已被消费，生产者可生产
                flag=true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  • 运行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-milHTayt-1665656449417)(assets/image-20211120173647695.png)]

线程池

缓存线程池

使用 Executors.newCachedThreadPool() 创建一个线程池对象

使用execute方法添加任务并自动执行

public class ExecutorDemo {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });

    }
}

定长线程池

使用Executors.newFixedThreadPool()创建一个线程池对象

使用execute方法添加任务并自动执行

public class ExecutorDemo {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
    }
}

单线程线程池

线程池中只有一个线程，每次执行都是相同的线程

Executors.newSingleThreadExecutor();

public class ExecutorDemo {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行了");
            }
        });
    }
}

周期定长线程池

public class ExecutorDemo {

    public static void main(String[] args) {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
        //定时执行一次
        executorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行了 只执行一次");
            }
        },1, TimeUnit.SECONDS);

        //定时多久执行一次
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行了 每秒一次");
            }
        },2,1, TimeUnit.SECONDS);
    }
}
微风一片轻吹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程——线程安全及实现机制
qq_42583242的博客
08-23 596
多线程——线程安全及实现机制 文章目录多线程——线程安全及实现机制一、线程安全概念二、Java 语言中的线程安全1、不可变2、绝对线程安全3、相对线程安全（重要）4、线程兼容三、线程安全的实现机制1、互斥同步(Synchronized、Reentrantlock)2、非阻塞同步(CAS、原子类)3、无同步方案（ThreadLocal）四、总结 一、线程安全概念 讨论线程安全，需要以多个线程之间存在共享数据访问为前提。因为如果根本不存在多线程，又或者一段代码根本不会与其他线程共享数据，那么从线程安全的角度来看
Java线程实现与安全
01-27
Java线程实现与安全在Java编程中至关重要，因为并发...总的来说，Java线程实现与安全是一个复杂而重要的主题，开发者需要理解线程的创建、调度以及如何保证并发环境下的数据安全性，才能编写出高效且可靠的多线程程序。
实现多线程安全的3种方式
热门推荐
jinggod的博客
10-18 3万+
1、先来了解一下：为什么多线程并发是不安全的？  在操作系统中，线程是不拥有资源的，进程是拥有资源的。而线程是由进程创建的，一个进程可以创建多个线程，这些线程共享着进程中的资源。所以，当线程一起并发运行时，同时对一个数据进行修改，就可能会造成数据的不一致性，看下面的例子： 假设一个简单的int字段被定义和初始化： int counter = 0; 该counter字段在两个线程A和B
Java多线程线程安全实现方式
YEN_CSDN的博客
06-17 1万+
线程安全就是要保证数据的高度一致性和准确性，但不是一定要加锁才是线程安全性，只要代码里没有变量互串，线程之间互不影响，就是线程安全的。 要了解线程安全，可以先看一下线程不安全是怎样的一种现象。public class TreadNoSafeDemo { public static void main(String[] args) { new ThreadNoSafeTest(
多线程的线程安全
Damon_zqt的博客
04-16 93
线程安全 多个线程共享同一个全局成员变量时，做写的操作可能会发生数据冲突问题。 例子： package com.zqt.basicproject; public class MyThread implements Runnable { private int ticket = 50;//票的数量为5 @Override public void run() {//覆写r...
多线程的实现及其安全问题
weixin_34407348的博客
08-23 68
一、进程和线程概述1、进程：进程是一个具有独立功能的程序关于某个数据集合的一次运行活动，简单来说开启一个程序就开启了一个进程；如果开启多个进程，它们之间是由于CPU的时间片在相互的切换；2、线程：开启一个进程的一个任务,对于多线程:每一个线程都在争夺CPU的执行权(CPU的执行权具有随机性)；如果一个程序的执行路径有多条，那么该线程是多线程;反之，就单线程线程；线程是依赖于进...
如何实现Java线程安全问题
08-25
Java线程安全问题是指在多线程编程中，多个线程访问共享资源时可能出现的数据不一致、数据丢失或程序崩溃等问题。为了解决这些问题，Java提供了多种解决方案，包括使用同步代码块、同步方法和lock锁等。 使用同步...
ArrayList源码和多线程安全问题分析
08-25
ArrayList源码和多线程安全问题分析 在 Java 编程语言中，ArrayList 是一个常用的集合类，它提供了动态数组的实现，能够存储大量的数据。但是，在多线程环境下，ArrayList 并不是线程安全的。这篇文章主要介绍了 ...
Java多线程之CAS算法实现线程安全
08-25
"Java多线程之CAS算法实现线程安全" 在Java中，实现线程安全是一项至关重要的任务。一般来说，我们可以通过添加锁机制、同步机制来实现线程安全，但是这些方法都有其缺陷，例如降低性能、增加系统复杂度等。那么，...
Java多线程及线程安全实现方法解析
08-19
一、Java多线程实现的两种方式 Java多线程可以通过继承Thread类或实现Runnable接口来实现。下面是两种方法的示例代码： 1、继承Thread类 public class MyThread extends Thread{ @Override public void run() {...
Java 线程问题 多线程的实现方式的简单实例 与 线程安全
一只菜鸡
06-30 964
​ 线程 是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。 ​ 每个线程都有一个优先级，高优先级线程的执行优先于低优先级线程。每个线程都可以或不可以标记为一个守护程序。当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。 进程: 1. 正在运行的程序，是系统运行和资源...
多线程：线程安全的实现方法。
孤芳不自赏
06-06 217
互斥同步 互斥同步（Mutual Exclusion&Synchronization）是常见的一种并发正确性保障手段。同步是指多个线程并发访问数据时，保证共享数据在同一个时刻只被一个线程（或者是一些，使用信号量的时候）使用。而互斥是实现同步的一种手段，临界区（Critical Section）、互斥量（Mutex）和信号量（Semaphore）都是主要的互斥实现方式。因此，在这4个字里面...
多线程编程的安全问题和解决措施
最新发布
yahid的博客
05-02 953
由于多线程并发执行，导致结果出错，我们称这种线程是不安全的。
Java多线程之线程安全的实现方法
boker_han的博客
03-08 1044
同步互斥（阻塞式同步） 同步互斥是一种常见的并发正确保障手段；其中，同步是指在同一个时刻，多个线程中只能有一个线程去访问共享变量；互斥是指实现同步的一种手段，如临界区、互斥量和信号量； 在Java中，最基本的互斥同步手段就是synchronized关键字；synchronized关键字经过编译后，会在同步块的前后分别形成monitorenter和monitorexit两条字节码指令， ...
什么是多线程? 了解多线程的实现方式 线程方法 及线程安全问题
m0_68979682的博客
07-27 525
是指从软件或者硬件上实现多个线程并发执行的技术具有多线程能力的计算机因为有硬件的支持而能够在同一时间执行多个线程,提高性能并发和并行并行同一个时刻,多个指令在多个cpu上并发同一个时刻,多个指令在一个cpu上进程和线程什么是进程进程正在运行的软件>独立性进程是一个能独立运行的基本单位,同时也是系统分配资源和调度的独立单位>动态性进程的实质是程序的一次执行过程,进程是动态产生,动态消亡的>并发性任何进程都可以同其他进程一起并发执行...
多线程线程安全
须臾-code
07-09 221
1.什么是线程安全问题？当多个线程共享同一个全局变量，做写的时候可能会受到其他线程的干扰，导致数据由问题，这种现象叫做线程安全问题。但是做读的操作是不会发生数据冲突问题。2.多个线程共享同一个局部变量会发生线程安全问题？不会。3.线程安全问题有哪些解决方法？使用多线程之间同步synchronized或者使用锁（lock）lock--jdk.5并发包--手动synchronized--自动一.什么地...
多线程与线程安全，实现多线程的三种方法
Jack__iT的博客
09-26 191
创建线程的方式： 继承 Thread 类创建线程类 一、定义 Thread 类的子类，并重写该类的 run 方法，该 run 方法的方法体就代表了线程要完成的任务。因此把 run() 方法称为执行体。 创建 Thread 子类的实例，即创建了线程对象。 调用线程对象的 start() 方法来启动该线程。 通过 Runnable 接口创建线程类 public class ThreadTest...
多线程，单线程，线程安全，同步，异步的区别
weixin_33785108的博客
03-22 145
本文是总结知乎上面的知识点，虽然忘记了具体的链接地址，但是还是非常感谢知乎里面各位大神的分享！   java 中使用 synchronized 是用来 表示该资源或者该方法是不能进行多个线程的共享的，所以当多个线程都在请求该资源的时候，就跟串行是一样的也就是单线程效果一样，但是当不为共享的时候就可以利用并发来大大的提高系统的效率。1、多线程并不解决软件执行效率和你硬件系统的瓶颈，它只是达到更高效使...
Java多线程实现与示例详解
Java的多线程设计是Java编程中的核心概念，它允许程序同时执行多个...然而，线程安全和并发问题也是多线程编程中需要特别关注的部分，需要正确使用synchronized关键字、wait/notify等机制来避免数据竞争和死锁等问题。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值