JAVA多线程(二)

最新推荐文章于 2021-10-04 21:57:14 发布
最新推荐文章于 2021-10-04 21:57:14 发布
阅读量181 收藏
点赞数
分类专栏： Java类 文章标签： java thread 多线程 runnable
[size=x-large]资源竞争 (线程互斥)[/size]
[size=medium]1、什么是资源竞争[/size]
　　有这样一种资源，在某一时刻只能被一个线程所使用：比如打印机、某个文件等等，如果多个线程不加控制的同时使用这类资源，必然会导至错误。
　　下面的例子模拟了一个打印机，多个线程不加控制的同时使用这个打印机： 
public class Printer
{
    public void print(int printer, String content)
    {
        System.out.println("Start working for [" +printer+"]");
        Thread.yield();
        System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
        Thread.yield();
        System.out.println(content);
        Thread.yield();
        System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
        Thread.yield();
        System.out.println("Work complete for [" +printer+"]\n");
    }

    public static void main(String[] args)
    {
        Printer p = new Printer();

        for (int i=0; i<3; i++)
            new Thread(new MyThread(p)).start();
    }
}

class MyThread implements Runnable
{
    private static int counter = 0;
    private final int id = counter++;

    private Printer printer;

    public MyThread(Printer printer)
    {
        this.printer = printer;
    }

    @Override
    public void run()
    {
        printer.print(id, "Content of " + id);
    }

}

　　输出结果(sample) 
Start working for [0]
Start working for [1]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Start working for [2]
Content of 0
Content of 1
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Content of 2
Work complete for [0]

Work complete for [1]

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Work complete for [2]

　　从结果可以看到，打印机的输出完全乱套了，各个线程想要打印的内容全部参杂在一起了。

[size=medium]2、解决资源竞争问题[/size]
　　原则上要解决这类问题并不难，只需要一个锁的机制。任何线程在使用打印机前必须先对打印机上锁；在使用完打印机后释放锁；如果线程尝试对打印机上锁时别的线程已经上了锁，则该线程必须等待别的线程先释放锁。
　　Java中，解决上述资源共享类的问题是通过关键字synchronized实现的。java中的对象都有一个‘锁’，这样，任何一个线程尝试访问对象的synchronized方法时，必须要先获得对象的'锁'，否则必须等待。
　　一个对象可能会有多个synchronized方法，比如synchronized a()方法和synchronized b()方法。当一个线程获得了对象的锁，进行a()方法、或b()方法了，那么在线程释放该对象的锁之前，别的线程是不能访问该对象的其它synchronized方法的。
　　下面例子是之前的例子的改良版本，只需要简单的把Printer对象的print方法定义成synchronized的就可以达到我们的要求了： 
public class Printer
{
    public synchronized void print(int printer, String content)
    {
        System.out.println("Start working for [" +printer+"]");
        Thread.yield();
        System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
        Thread.yield();
        System.out.println(content);
        Thread.yield();
        System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
        Thread.yield();
        System.out.println("Work complete for [" +printer+"]\n");
    }

    public static void main(String[] args)
    {
        Printer p = new Printer();

        for (int i=0; i<3; i++)
            new Thread(new MyThread(p)).start();
    }
}

class MyThread implements Runnable
{
    private static int counter = 0;
    private final int id = counter++;

    private Printer printer;

    public MyThread(Printer printer)
    {
        this.printer = printer;
    }

    @Override
    public void run()
    {
        printer.print(id, "Content of " + id);
    }

}

　　输出结果 
Start working for [0]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Content of 0
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Work complete for [0]

Start working for [2]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Content of 2
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Work complete for [2]

Start working for [1]
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Content of 1
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Work complete for [1]

　　从结果的输出可以看出来，被模拟的打印机资源在某一时刻，仅被一个线程所使用。

[size=medium]3、临界区[/size]
　　有些时候，你可能不需要隔离整个方法，而只需要隔离方法中的部分代码，这部分被隔离的代码就叫做临界区。临界区中的代码在某一时刻，只能被一个线程访问。
　　下面的例子，是用临界区的方式实现了前面的例子： 
public class Printer
{
    public void print(int printer, String content)
    {
        synchronized(this)
        {
            System.out.println("Start working for [" +printer+"]");
            Thread.yield();
            System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
            Thread.yield();
            System.out.println(content);
            Thread.yield();
            System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
            Thread.yield();
            System.out.println("Work complete for [" +printer+"]\n");
        }
    }

    public static void main(String[] args)
    {
        Printer p = new Printer();

        for (int i=0; i<3; i++)
            new Thread(new MyThread(p)).start();
    }
}

class MyThread implements Runnable
{
    private static int counter = 0;
    private final int id = counter++;

    private Printer printer;

    public MyThread(Printer printer)
    {
        this.printer = printer;
    }

    @Override
    public void run()
    {
        printer.print(id, "Content of " + id);
    }

}

　　可以看到，在Java中临界区也是通过synchronized关键字实现的。在synchronized关键字后面，要传一个对象参数，任何线程要进入临界区时必须先要获得该对象的锁，退出临界区时要释放该对象的锁，这样别的线程才有机会进入临界区。
　　从上面两个例子可以看出，临界区和synchronized方法，其原理都是一样的，都是通过在对象上加锁来实现的，只不过临界区来得更加灵活，因为它不光可以对this对象加锁，也可以对任何别的对象加锁。

[size=medium]4、Lock[/size]
　　Java1.5提供了一个显示加锁的机制，比起synchronized方式来说，显示加锁的方法可能让代码看上去更加复杂，但是也带来了更好的灵活性。
　　下面的例子，用Lock的机制实现了前面的例子： 
public class Printer
{
    private Lock lock = new ReentrantLock();

    public void print(int printer, String content)
    {
        lock.lock();

        try
        {
            System.out.println("Start working for [" +printer+"]");
            Thread.yield();
            System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
            Thread.yield();
            System.out.println(content);
            Thread.yield();
            System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
            Thread.yield();
            System.out.println("Work complete for [" +printer+"]\n");
        }
        finally
        {
            lock.unlock();
        }
    }

    public static void main(String[] args)
    {
        Printer p = new Printer();

        for (int i=0; i<3; i++)
            new Thread(new MyThread(p)).start();
    }
}

class MyThread implements Runnable
{
    private static int counter = 0;
    private final int id = counter++;

    private Printer printer;

    public MyThread(Printer printer)
    {
        this.printer = printer;
    }

    @Override
    public void run()
    {
        printer.print(id, "Content of " + id);
    }

}

　　使用Lock的时候，必须要注意两点：
[list]
[*]锁的释放必须放在finally块里面，以保证锁被正确的释放；
[*]如果被隔间的方法或临界间需要返回一个值，那么return语句应该放在try块中，从而不至于使unlock发生得过早而导至错误的发生。
[/list]
　　使用显示的Lock机制，可以让程序更加的灵活。比如上面的例子中，如果尝试使用打印机的时候，打印机正被别的线程所使用，那么早取消本次打印。要实现这样的功能，使用synchronized可能不太容易实现，但是使用Lock机制的话，就非常简单了： 
public class Printer
{
    private Lock lock = new ReentrantLock();

    public void print(int printer, String content)
    {
        boolean isLocked = lock.tryLock();

        if (!isLocked)
            return;

        try
        {
            System.out.println("Start working for [" +printer+"]");
            Thread.yield();
            System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
            Thread.yield();
            System.out.println(content);
            Thread.yield();
            System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
            Thread.yield();
            System.out.println("Work complete for [" +printer+"]\n");
        }
        finally
        {
            if(isLocked)
                lock.unlock();
        }
    }

    public static void main(String[] args)
    {
        Printer p = new Printer();

        for (int i=0; i<3; i++)
            new Thread(new MyThread(p)).start();
    }
}

class MyThread implements Runnable
{
    private static int counter = 0;
    private final int id = counter++;

    private Printer printer;

    public MyThread(Printer printer)
    {
        this.printer = printer;
    }

    @Override
    public void run()
    {
        printer.print(id, "Content of " + id);
    }

}

　　Lock.tryLock()方法尝试对lock对象加锁并返回一个boolean值，如果成功了，返回true，表明当前没有别的线程在使用打印机，那么当前线程将获得lock对象的锁，并继续打印；如果失败了，返回false，表明别的线程正在使用打印机，当前线程将简单的返回，而不是等待别的线程释放锁。
晓筱时代
关注
专栏目录
Java多线程下解决资源竞争的7种方法详解
08-25
主要介绍了Java多线程下解决资源竞争的7种方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java 资源竞争_Java并发：解决资源竞争
weixin_36168996的博客
02-12 223
解决资源竞争Java 提供关键字 synchronized 的内置支持。使用 Lock 对象。synchronized 关键字synchronized 关键字获取的锁分为 对象锁 和 类锁。public class Test {public synchronized void f(){}public synchronized static void g(){}}调用 f() 是获取的 Test 对...
java 资源竞争_Java-如何避免资源竞争问题
weixin_30647489的博客
02-19 356
生产者和消费者在同一时间段内共用同一个存储空间，生产者向空间里存放数据，而消费者取用数据，如果不加以协存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁解决流程：对独占空间加锁，阻塞和唤醒线程。下面是通过await()和signal()，即线程锁的方式来解决的package com.ch.egg;import...
Java并发编程——共享资源竞争问题
猫头夜鹰的小屋
10-04 365
由案例引出共享资源竞争问题，介绍相关概念，并使用 synchronized 实现共享资源访问互斥
java 线程 竞争_java多线程竞争
weixin_35995377的博客
02-12 163
import java.util.Timer;import java.util.TimerTask;class ComcatFun {// 通信函数int flag, flagTemp = 0;boolean isRun = false;public void isThreadWait(String strCMD, int intTemp) {if (flag > 10000) {flag ...
详解Java多线程处理List数据
08-26
二、为什么需要Java多线程处理List数据？ 在处理大规模数据时，使用单线程来处理List数据可能会导致程序执行速度慢，甚至出现卡顿的情况。使用多线程处理List数据可以将处理时间缩短，提高程序的执行效率。 三、...
Java多线程学习Java多线程学习Java多线程学习Java多线程学习.txt
最新发布
05-15
Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java多线程学习Java...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
汪文君JAVA多线程编程实战（完整不加密）
01-19
《汪文君JAVA多线程编程实战》是一本专注于Java多线程编程的实战教程，由知名讲师汪文君倾力打造。这本书旨在帮助Java开发者深入理解和熟练掌握多线程编程技术，提升软件开发的效率和质量。在Java平台中，多线程是...
Java多线程编程实战指南(核心篇)
07-17
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化，即在一块芯片上集成多个处理器内核（Core），多核处理器（Multicore Processor）离我们越来越近了――如今...
java实现多线程间的同步与互斥（读者写者问题）
12-25
用java实现多线程并发中的读者与写者问题，能够实现多线程对临界资源的同步有序访问。 具体实现为： 给定一个队列A[1-10][1-100000]、元素编号1-10，其中每个元素包含10万个随机数。创建若干个线程，各循环100次；其中10，100个为读线程，10，100个为更新线程。 1. 读线程每次产生随机数三元组：(i, j, k)，其中i: [1-10], j: [1-100000]，k[j-100000]，求取指定A[i]一级数组中第j到第k个元素的均值； 2. 更新线程每次产生一对随机整数三元组 (i, j, k) 和一个随机浮点数d:(0-1)，其中i: [1-10], j: [1-100000]，k[j-100000]，完成对A[i][j]到A[i][k]之间的所有元素进行数值更新，x = x * (1 + d)
java多线程资源竞争
白小白的小白的博客
05-27 1298
先看一下java多线程资源竞争的案例 /* 当多个线程访问同一个变量时，这个变量被称为共享变量,而当多个线程操作同一个变量时，就会出现资源竞争的问题， * 举例, 有个变量num为100， 每个线程对其的操作就是减去1(想想一下卖票系统，100个票，有三个售票员[三个线程])，有一个 * 在cpu哪里累死累活抢到了使用权，拿到了100，还没来的及去减1， 完了，cpu被第二只线程抢了过去，一看num还是100，然后执行了100-1 * num就这样变为了99，这时第一个cpu终于抢到了cpu的使用权.
java多线程竞争
03-14 673
import java.util.Timer; import java.util.TimerTask; class ComcatFun {// 通信函数 int flag, flagTemp = 0; boolean isRun = false; public void isThreadWait(String strCMD, int intTemp) { if (flag > 100
java解决共享资源竞争
pbyang_love的博客
01-04 263
https://www.cnblogs.com/ChenD/p/7880533.html
多线程竞争以及Java线程安全
weixin_43823085的博客
07-05 152
原子操作 原子操作是指不会被线程调度机制打断的最小操作单位。比如有一行代码 a += 1; 将变量a的值加1，这条语句的执行将会被分成3个原子操作 从变量a的存储空间中取出a原本的值 计算a原本的值加1后的值 将计算结果写回a的存储空间 竞争 由于多线程通过时间分片来达到线程间的并发效果，而时间分片是由操作系统或是JVM自动调度，不受程序编写者控制，在多线程执行时就会出现意料之外的结果。比如 public class MyThread implements Runnable{ public int
java多线程（二）解决共享资源竞争
three__stones的博客
05-12 4026
【博客为自己复习准备面试知识梳理、总结用，如有错误，望各路大神指正，不胜感激！】 1、问题的出现 /* * 这是一个整数生成器 * canceled 表示这个对象是否已被取消 * */ public abstract class IntGenerator { private volatile boolean canceled = false; public abstract int
java多线程资源互斥访问
archer的技术故事
03-08 3741
java多线程——资源互斥访问 本文首先介绍一下java实现多线程的几种方式，再介绍一下如何实现资源的互斥访问，最后介绍生产环境中线程池的应用。 好，下面上货。 一、创建线程的两种方式： 1、继承Thread类。 package com.xueyoucto.xueyou; public class FirstThread extends Thread { public Firs
java 线程 资源_Java多线程下解决资源竞争的7种方法详解
weixin_39635459的博客
02-12 246
前言一般情况下，只要涉及到多线程编程，程序的复杂性就会显著上升，性能显著下降，BUG出现的概率大大提升。多线程编程本意是将一段程序并行运行，提升数据处理能力，但是由于大部分情况下都涉及到共有资源的竞争，所以修改资源对象时必须加锁处理。但是锁的实现有很多种方法，下面就来一起了解一下在C#语言中几种锁的实现与其性能表现。一、c#下的几种锁的运用方式1、临界区，通过对多线程的串行化来访问公共资源或一段代...
java多线程抢占资源_Java多线程整理
weixin_28880179的博客
02-16 1816
一、线程池过于频繁的创建/销毁线程浪费性能，线程并发数量过多，JVM调度是抢占式的，线程上线文切换抢占系统资源导致阻塞。1.线程池线程数：一般CPU密集型：CPU+1IO密集型：[(线程等待时间+线程CPU时间)/线程CPU时间]*CPU2.线程池创建4种方式：newCachedThreadPool 缓存线程池，没有线程可用就创建，空闲线程60秒未使用将被回收。newFixedThreadPoo...
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值