Java线程进阶

最新推荐文章于 2021-09-21 21:33:15 发布
最新推荐文章于 2021-09-21 21:33:15 发布
阅读量260 收藏
点赞数
分类专栏： Java基础 文章标签： java 多线程 并发编程 后端 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MarkZQP/article/details/106222610
版权

线程同步（多个线程操作同一个资源）

  • 线程同步： 其实就是一种等待机制，多个对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
  • 线程同步概念保证了某个资源在某一时刻只能有一个线程来访问，来保证共享数据的一致性。

不安全的线程使用案例

//线程不安全，买到负数的票，或者买到了同一张票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket=new BuyTicket();
        Thread thread=new Thread(buyTicket,"小张");
        Thread thread2=new Thread(buyTicket,"小红");
        Thread thread3=new Thread(buyTicket,"小李");
        thread.start();
        thread2.start();
        thread3.start();
    }
}

class BuyTicket implements Runnable{
    private int ticketNums=10;
    boolean flag=true;//线程停止方式使用外部停止方式
    @Override
    public void run() {
        while (flag){
            ButTicket();
        }
    }
    public void ButTicket(){
        if(ticketNums<=0){
            flag=false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"买了第"+ticketNums--+"张票");
    }
}

代码结果：在这里插入图片描述

线程安全解决

同步方法

同步方法是使用synchronized关键字修饰需要同步的方法其格式如下：

[访问修饰符] synchronized 返回类型 方法名([参数列表]){
     //方法体
 }

案例解决代码


public class safeBuyTicket {public static void main(String[] args) {
    BuyTicket2 buyTicket=new BuyTicket2();
    Thread thread=new Thread(buyTicket,"小张");
    Thread thread2=new Thread(buyTicket,"小红");
    Thread thread3=new Thread(buyTicket,"小李");
    //thread.setPriority(1);
    thread.start();
    thread2.start();
    thread3.start();
}
}

class BuyTicket2 implements Runnable{
    private int ticketNums=10;
    boolean flag=true;//线程停止方式使用外部停止方式
    @Override
    public void run() {
        while (flag){
            ButTicket();
        }
    }
    public synchronized void ButTicket(){
        if(ticketNums<=0){
            flag=false;
            return;
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"买了第"+ticketNums--+"张票");
    }
}

同步代码块

使用同步代码块实现同步功能，只需要将对实例的访问语句放入一个同步块中，其语法格式如下：

//要千万注意，要锁对对象才能保证线程安全
synchronized(object){
        //所需要同步的代码块
}

同步代码块使用案例

package Thread;

public class SynBlockBank extends Thread {
    //银行账户
    private BankAccount account;
    //操作金额，正数为存钱，负数为取钱
    private double money;
    public SynBlockBank(String name,BankAccount account,double money){
        super(name);
        this.account=account;
        this.money=money;
    }

    @Override
    public void run() {
        synchronized (account){
            double d=this.account.getBalance();
            if(money<0&&d<-money){
                System.out.println(this.getName()+"操作失败，余额不足！");
                return;
            }else {
                d+=money;
                System.out.println(this.getName()+"操作成功，目前账户余额为："+d);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.account.setBalance(d);
            }
        }
    }

    public static void main(String[] args) {
        BankAccount bankAccount=new BankAccount("2020520",5000);
        SynBlockBank t1=new SynBlockBank("T001",bankAccount,-3000);
        SynBlockBank t2=new SynBlockBank("T002",bankAccount,-3000);
        SynBlockBank t3=new SynBlockBank("T003",bankAccount,1000);
        SynBlockBank t4=new SynBlockBank("T004",bankAccount,-2000);
        SynBlockBank t5=new SynBlockBank("T005",bankAccount,2000);
        t1.start();     //启动线程
        t2.start();     //启动线程
        t3.start();     //启动线程
        t4.start();     //启动线程
        t5.start();     //启动线程
        try{
            //等待所以子线程完成
            t1.join();t2.join();t3.join();t4.join();t5.join();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("账户"+bankAccount.getBankNo()+"最终余额为："+bankAccount.getBalance());
    }
}
class BankAccount {
    private String bankNo;
    private double balance;

    public BankAccount(String bankNo, double balance) {
        this.bankNo = bankNo;
        this.balance = balance;
    }

    public String getBankNo() {
        return bankNo;
    }

    public void setBankNo(String bankNo) {
        this.bankNo = bankNo;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题
死锁产生的四个必要条件：

  • 互斥条件：一个资源每次只能被一个进程使用
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已经获得的资料保持不放
  • 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
  • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
    那么如何避免死锁呢？-我们只有想办法破坏其中的任意一个或者多个条件就可以避免死锁发生。

同步锁（Lock锁）

原理与同步代码块是一样的，只不过是加锁方法和形式不一样而已，看一个案例就可以理解了

import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
    public static void main(String[] args) {
        BuyTicket3 buyTicket=new BuyTicket3();
        Thread thread=new Thread(buyTicket,"小张");
        Thread thread2=new Thread(buyTicket,"小红");
        Thread thread3=new Thread(buyTicket,"小李");
        thread.start();
        thread2.start();
        thread3.start();
    }
}

class BuyTicket3 implements Runnable{
    private int ticketNums=10;
    boolean flag=true;//线程停止方式使用外部停止方式
    private final ReentrantLock lock=new ReentrantLock();//定义Lock锁
    @Override
    public void run() {
        while (flag){
            ButTicket();
        }
    }
    public void ButTicket(){
        try{
            lock.lock();//加锁
            if(ticketNums<=0){
                flag=false;
                return;
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买了第"+ticketNums--+"张票");
        }finally {
            lock.unlock();//解锁
        }
    }
}

线程通信

Java中提供了一些机制来保证线程之间的协调运行，这就是所谓的线程通信，
需求假设 ： 目前有系统有生产和消费两个线程，系统要求不断重复生产，消费操作，并要求每当一个线程生产后，另一个线程立即进行消费，不允许连续两次生产，也不允许连续两次消费。为了实现这种功能，可以采用线程之间的通信技术。
线程通信可以使用Object类中定义的wait()，notify(),和notifyAll()方法，使线程之间互相进行事件通知。执行这些方法时，必须拥有相关对象的锁。

  • wait()方法，让当前线程等待，并释放对象锁，直到其他线程调用该监视器的notify()或notifyAll()来唤醒该线程。wait()方法也可以带一个参数，用于指名等待的时间，使用此种方式不需要notify()或notifyAll()的唤醒。wait()方法只能在一个同步方法中调用。
  • notify()方法：唤醒在此同步监视器上等待的单个线程，解除该线程的阻塞状态。
  • notifyAll()方法：唤醒在此同步监视器上等待的所有线程，唤醒次序完全由系统来控制。
    注意 : notify()和notifyAll()方法只能在同步方法或者同步块中使用。wait()方法区别于sleep()方法之处：wait()方法调用时会释放对象锁，而sleep()方法不会。

代码通过生产/消费模型演示线程通信机制的应用

package Thread;
public class WaitDemo {
    public static void main(String[] args) {
     //实例化一个产品对象，生产者和消费者共享该实例
     Product product=new Product();
     //指定生产线程
     Producer producer=new Producer(product);
     //指定消费线程
     Consumer consumer=new Consumer(product);
    }
}
class Product{
    int n;
    //为true时表示有值可取，为false时表示需要放入新值
    boolean valueSet=false;
    //生产方法
    synchronized void put(int n){
        if (valueSet){
            try{
                wait();
            }catch (Exception e){
            }
        }
        this.n=n;
        //将valueSet设置为true，表示值已经放入
        valueSet=true;
        System.out.println(Thread.currentThread().getName()+"-生产："+n);
        notify();
    }
    //消费方法
    synchronized void get(){
        if(!valueSet){
            try{
                wait();
            }catch (Exception e){
            }
        }
        System.out.println(Thread.currentThread().getName()+"-消费："+n);
        valueSet=false;
        notify();
    }
}
//生产者
class Producer implements Runnable{
    Product product;
    public Producer(Product product){
        this.product=product;
        new Thread(this,"Producer").start();
    }
    @Override
    public void run() {
        int k=0;
        //生产10次
        for (int i = 0; i < 10; i++) {
            product.put(k++);
        }
    }
}
//消费者
class Consumer implements Runnable{
    Product product;
    public Consumer(Product product){
        this.product=product;
        new Thread(this,"Consumer").start();
    }
    @Override
    public void run() {
        //消费10次
        for (int i = 0; i < 10; i++) {
            product.get();
        }
    }
}

执行结果如下：在这里插入图片描述

线程通信案例2

代码：

public class Demo06 {
    static Object object = new Object();
    public static class T1 extends Thread{
        @Override
        public void run(){
            synchronized (object){
                System.out.println("T1 start!");
                try{
                    System.out.println("T1 wait for object");
                    object.wait();
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("T1 end");
            }

        }
    }
    public static class T2 extends Thread{
        @Override
        public void run(){
            synchronized (object){
                System.out.println("T2 start, notify one thread");
                object.notify();
                System.out.println("T2 end!");
                try{
                    Thread.sleep(2000);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }

        }
    }
    public static void main(String[] args) throws Exception {
        new T1().start();
        new T2().start();
    }
}

执行结果如下：
在这里插入图片描述
注意：注意下打印结果，T2调用notify方法之后，T1并不能立即继续执行，而是要等待T2释放objec投递锁之后，T1重新成功获取锁后，才能继续执行。因此最后2行日志相差了2秒（因为T2调用notify方法后休眠了2秒）。

MarkZQP
关注
专栏目录
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4249
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
【Java多线程进阶】线程池详解
最新发布
我的主页
05-31 3816
本文讲解：Java 如何创建线程池，以及线程池底层的类，线程池的四个拒绝策略，模拟实现线程池。
多线程——多线程同步的三种实现方法
热门推荐
Searchin_R的博客
12-01 1万+
当使用多线程访问同一个资源的时候，非常容易出现线程安全的问题（例如，当多个线程同时对一个数据进行修改的时候，会导致某些线程对数据的修改丢失）。 因此，需要采用同步机制来解决这种问题。而Java主要提供了三种实现同步机制的方法。今天我们就来认识一下~~ 一、synchronized关键字 在Java语言中，每个对象都有一个对象锁与之相关联，该锁表明对象在任何时候只允许被一个线程锁拥有，当一个线...
如何保证线程安全（线程同步）
weixin_39590058的博客
03-14 661
互斥同步（悲观策略） 同步是指在多个线程并发访问共享数据时，保证共享数据在同一个时刻只被一个（或者时一些，使用信号量的时候）线程使用。 synchronized ReentrantLock 非阻塞同步（乐观策略） 互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题。 ：基于冲突检测的乐观并发策略，通俗的说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了。 CAS操作 ...
javaWeb中如何防止两个人同时操作同一条记录（限制单人操作），使用redis的解决方式
qq_42755868的博客
04-17 7870
最近在做demo的时候，碰到这么一个问题：当页面上同一角色有两个人登录的时候，他们同时操作统一条记录； 简言之就是，同一记录同一时刻多人操作。这种情况在我的业务中回导致数据的冗余，干扰正常的程序运行。 当时想到的解决办是锁表或者使用缓存（当然其他的方式可以在下方留言探讨~），锁表没有尝试过所以自然就想到了缓存。 实现思路是，当页面端用户选中记录并且进行操作的时候，在服务端先不进行业务处理，而是...
使用分布式锁来限制同一条数据同一时间只有一个人才能操作
qq_35780926的博客
05-22 966
实现分布式锁有三种方式：基于数据库实现分布式锁、基于redis实现分布式锁、基于zookeeper实现分布式锁。本文讲解的是基于redis实现分布式锁，其它两种情况，大家可以自行百度学习。 实现思路： 操作数据之前，先到redis判断是否存在该数据的缓存数据，如果存在，说明该数据已经被其它人加锁使用；不存在，则向redis存入该数据的缓存数据进行加锁，然后再进行数据的操作，操作结束后删除redis中该数据的缓存来释放锁。(根据实际应用场景，可以在设置锁的时候，设置一个过期时间，超过该时间则主动删除redis
java并发编程之锁
weixin_45989389的博客
07-21 109
java并发编程的各种锁 1.乐观锁 ​ 乐观锁并不是一种真正的锁，基于cas的思想，认为，并发操作不会修改数据的值。 ​ 适用于读比较多的场景（不阻塞线程，大大提效率） 2.悲观锁 ​ 悲观锁认为并发操作会对数据进行修改，认为并发操作不加实际的锁会出现错误， ​ 适用于写比较多的操作 3.公平锁 ​ 在程序在并发操作时，一个加锁的线程工作，其他的线程会进入阻塞队列，当加锁的线 程运行结束阻塞队列的下一个线程获得cpu。（优先给排队时间最长的线程） 4非公平锁 ​ 非公平锁，当一个加锁线程在运行时，其他线程
java多线程进阶
10-18
这本书“java多线程进阶”显然旨在帮助读者深化这方面的理解，打通编程中的“任督二脉”，使开发者能够更加熟练地在并发环境中编写高效且稳定的代码。 1. **线程基础**：书中首先会介绍Java多线程的基础知识，包括...
java虚拟机多线程进阶篇总结
08-25
Java虚拟机多线程进阶篇总结 Java虚拟机多线程进阶篇总结是Java开发中一个非常重要的知识点，本节内容将会对Java虚拟机多线程进阶篇进行总结，帮助读者更好地理解Java虚拟机多线程的实现原理和应用。 一、线程池...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶 Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC...
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口（csdn）————程.pdf
12-05
在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口（csdn）————程
并发线程同时访问同一资源时，其中一线程访问，其它线程忽略掉访问
iteye_5975的博客
12-11 168
解决代码示意： if(lock.tryLock()){ System.out.println(Thread.currentThread()+"建立socket连接:"); Thread.sleep(10000); lock.unlock(); }else{ Syst...
Java线程：线程的同步与锁
weixin_33908217的博客
09-13 319
Java线程：线程的同步与锁       一、同步问题提出   线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。 例如：两个线程ThreadA、ThreadB都操作同一个对象Foo对象，并修改Foo对象上的数据。   public class Foo {     private int x = 100;     public int getX() {  ...
浅谈Java锁
Nicer_feng's blog
09-06 361
最近被遇到很多Java锁的问题，实在是有点头痛，什么互斥锁、自旋锁、偏向锁、轻量锁、重量锁、公平非公平……今天小小的总结一下Java里的那些锁。 各种锁一览 首先总结一下锁的种类，具体如下： （xmind用免费版不会找我吧） 乐观锁&悲观锁 乐观锁 乐观锁可以从字面理解，就是一把乐观的锁，他觉得他遇不到并发的情况，在每次操作数据的时候，认为别人不会动他的数据（修改数据），所以也不上锁，但也不是什么也不干，在更新的时候会判断一下版本号，具体方法是，写数据操作时先读取当前版本号，然后更新时确定版本号是
java synchronized 理解
weixin_47503016的博客
09-21 202
synchronized 概念： 是java中的一个关键字； 作用给特定代码加锁，使同一时刻只能有一个线程能够访问这部分代码； 按加锁的target分，分为 对象锁（this）、类锁（Object.class） 两种，因为静态代码和Object.class的关系出现了类锁（一个类只有一个Object.class)； 可以存在的地方，方法，方法内部（代码块），不能出现在构造方法上，但是可以以代码块的形式存在构造方法内部； 由于一个对象只有一把锁，所以如果一个类有多个synchronized
【基础笔记】多线程的同步与协作 Java
michiko98的博客
04-13 150
多线程的同步 多线程同步控制机制的目的是保证同一时刻只有一个线程访问共享数据。java中，要实现多线程的同步，可使用同步方法和同步代码块两种机制。 1. 同步方法 使用synchronized修饰的方法称为同步方法，它意味着同一时刻该方法只能被一个线程执行，其它想执行该方法的线程必须等待(处于不可运行状态)，直到获得同步锁之后才能执行(处于可运行状态)。 public synchronized...
java基础笔试题
qq_45793052的博客
11-10 3556
**面试题大全 对于abstract声明的类，下面说法正确的是( E )** A.可以实例化 B.不可以被继承 C子类为abstract D.只能被继承E.可以被抽象类继承 **解析：**A：abstract声明的类是抽象类，不能被实例化 B：抽象类可以被继承 C：如果子类实现了该类，则为实体类 D：说法太肯定 以下关于集合类ArrayList、LinkedList、HashMap描述错误的是( C ) A. HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值 B. Ar
Java多线程---线程同步的三种方法
卿霜寒墨的博客
09-10 710
当多线程并发（指两个或多个事件在同一个时间段内发生）时，容易发生线程不安全的问题，我们希望某一段代码执行的过程中CPU不要切换到其它线程工作，这时就需要同步。 线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法。 同步代码块 格式：synchronized（锁对象）{执行代码块} synchronized的目的是使同一个对象的多个线程，在某个
Java多线程编程进阶指南
1. 线程状态：Java线程有新建、可运行、运行、阻塞、等待、终止等状态，了解这些状态有助于理解和解决问题。 2. 生命周期管理：包括启动线程（start()），停止线程（通常不推荐直接使用stop()，应通过共享变量或中断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值