Java多线程

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量279 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/RussellWestbrook/p/4256127.html
版权

线程同步

假设创建并启动100个线程，每个线程都往同一个账户中添加一个便士。非同步状态下得到的结果是2。

package com.halin.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class AccountWithoutSync {

    private static Account account = new Account();
    
    public static void main(String[] args) {
        
        ExecutorService executor = Executors.newCachedThreadPool();
        
        for (int i = 0; i < 100; i++) {
            executor.execute(new AddAPennyTask());
        }
        
        executor.shutdown();
        
        while (!executor.isTerminated()) {
            
        }
        
        System.out.println("What is balance ? " + account.getBalance());
        
    }
    
    private static class AddAPennyTask implements Runnable {
        public void run() {
            account.deposit(1);
        }
    }
    
    private static class Account {
        
        private static Lock lock = new ReentrantLock();
        private int balance = 0;
        
        public int getBalance() {
            return balance;
        }
        
        public void deposit(int amount) {
            
//            lock.lock();
            
            int newBalance = balance + amount;
            
            try {
                Thread.sleep(5);
            }
            catch (InterruptedException ex) {
                
            }
            
            balance = newBalance;
            
//            lock.unlock();
            
        }
        
    }
    
}
View Code

要实现同步，可在deposit方法前添加关键字synchronized来实现一个隐式锁，也可以直接添加显式锁来lock()和unlock()。显式锁对同步具有状态的线程更加直观和灵活。只有一个许可的信号量也可以用来模拟一个相互排斥的锁。

private static class Account {
    
    private static Semaphore semaphore = new Semaphore(1);
    private int balance = 0;
    
    public int getBalance() {
        return balance;
    }
    
    public void deposit(int amount) {
        
        try {
            semaphore.acquire();
            int newBalance = balance + amount;
            Thread.sleep(5);
            balance = newBalance;
        }
        catch (InterruptedException ex) {
            
        }
        finally {
            semaphore.release();
        }
        
    }
    
}
View Code

 

线程间协作

假设创建并启动两个任务，一个用来向账户中存款，另一个从同一个账户提款。当提款的数额大于账户的当前余额时，提款线程必须等待。不管什么时候，只要向账户心存入一笔资金，存储线程必须通知提取线程重新尝试。如果余额仍未达到提款的数额，提取线程必须继续等待存入更多的资金。

package com.halin.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadCooperation {

    private static Account account = new Account();
    
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new DepositTask());
        executor.execute(new WithdrawTask());
        executor.shutdown();
        System.out.println("Thread 1\t\tThread 2\t\tBalance");
    }
    
    public static class DepositTask implements Runnable {
        public void run() {
            try {
                while (true) {
                    account.deposit((int) (Math.random() * 10) + 1);
                    Thread.sleep(1000);
                }
            }
            catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
    
    public static class WithdrawTask implements Runnable {
        public void run() {
            while (true) {
                account.withDraw((int) (Math.random() * 10) + 1);
            }
        }
    }
    
    public static class Account {
        
        private static Lock lock = new ReentrantLock();
        
        private static Condition newDeposit = lock.newCondition();
        
        private int balance = 0;
        
        public int getBalance() {
            return balance;
        }
        
        public void withDraw(int amount) {
            lock.lock();
            try {
                while (balance < amount) {
                    newDeposit.await();
                }
                balance -= amount;
                System.out.println("\t\t\tWithdraw " + amount + "\t\t" + getBalance());
            }
            catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            finally {
                lock.unlock();
            }
        }
        
        public void deposit(int amount) {
            lock.lock();
            try {
                balance += amount;
                System.out.println("Deposit " + amount + "\t\t\t\t\t" + getBalance());
                newDeposit.signalAll();
            }
            finally {
                lock.unlock();
            }
        }
        
    }
    
}
View Code

 

生产者消费者模型

假设使用缓冲区存储证书。缓冲区大小受限。缓冲区提供write(int)方法将一个int值添加到缓冲区，还提供方法read()从缓冲区中读取和删除一个int值。为了同步这个操作，使用具有两个条件的锁：notEmpty（即缓冲区非空）和notFull（即缓冲区未满）。当一个任务向缓冲区添加一个int时，如果缓冲区是满的，那么任务将会等待notFull状态。当任务从缓冲区中删除一个int时，如果缓冲区是空的，那么任务将等待notEmpty状态。

package com.halin.demo;

import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConsumerProducer {

    private static Buffer buffer = new Buffer();
    
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(new ProducerTask());
        executor.execute(new ConsumerTask());
        executor.shutdown();
    }
    
    private static class ProducerTask implements Runnable {
        public void run() {
            try {
                int i = 1;
                while (true) {
                    System.out.println("Producer writes " + i);
                    buffer.write(i++);
                    Thread.sleep((int)(Math.random() * 10000));
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
    
    private static class ConsumerTask implements Runnable {
        public void run() {
            try {
                int i = 1;
                while (true) {
                    System.out.println("\t\t\tConsumer reads " + buffer.read());
                    Thread.sleep((int)(Math.random() * 10000));
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
    
    private static class Buffer {
        
        private static final int CAPACITY = 1;
        private LinkedList<Integer> queue = new LinkedList<Integer>();
        private static Lock lock = new ReentrantLock();
        private static Condition notEmpty = lock.newCondition();
        private static Condition notFull = lock.newCondition();
        
        public void write(int value) {
            lock.lock();
            try {
                while (queue.size() == CAPACITY) {
                    System.out.println("Wait for notFull condition");
                    notFull.await();
                }
                queue.offer(value);
                notEmpty.signal();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        
        public int read() {
            int value = 0;
            lock.lock();
            try {
                while (queue.isEmpty()) {
                    System.out.println("\t\tWait for notEmpty condition");
                    notEmpty.await();
                }
                value = queue.remove();
                notFull.signal();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            } finally {
                lock.unlock();
            }
            return value;
        }
        
    }
    
}
View Code

ArrayBlockingQueue已现实同步，可代替Buffer，减少人工编码。

 

避免死锁

有时两个或多个线程需要锁定几个共享对象，这时可能引起死锁。也就是说，每个线程已经锁定一个对象，正在等待锁定另一个对象。考虑有两个线程和两个锁的情形。线程1锁定了locker1，等待locker2。线程2锁定了locker2，等待locker1。每个线程都等待另一个线程释放自己需要的锁，结果导致两个线程都无法继续运行。

package com.halin.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Deadlock {

    public static byte[] locker1 = new byte[0];
    public static byte[] locker2 = new byte[0];
    public static void main(String[] args) 
    {
        ExecutorService executor = Executors.newFixedThreadPool(100);
        for(int i = 0; i < 50; i++){
            executor.execute(new DeadlockTask1());
            executor.execute(new DeadlockTask2());
        }
        executor.shutdown();
        while(!executor.isTerminated()){
        
        }
        System.exit(0);
    }

    private static class DeadlockTask1 implements Runnable
    {
        public void run()
        {
            synchronized(locker1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("DeadlockTask1 获得锁 locker1");
                synchronized(locker2){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("DeadlockTask1 获得锁 locker2 没有死锁！");
                }
            }
        }
    }

    private static class DeadlockTask2 implements Runnable
    {
        public void run()
        {
            synchronized(locker2){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("DeadlockTask2 获得锁 locker2");
                synchronized(locker1){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("DeadlockTask2 获得锁 locker1 没有死锁！");
                }
            }
        }
    }
    
}
View Code

输出为：

DeadlockTask1 获得锁 locker1
DeadlockTask2 获得锁 locker2

如果Thread.sleep(1000)的话，可能就不会死锁，因为处理太快了。

解决方法很简单，为共享资源的锁排序，按序加锁。先锁定locker1，再锁定locker2。

package com.halin.demo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class LockInOrder {

    public static byte[] locker1 = new byte[0];
    public static byte[] locker2 = new byte[0];
    public static void main(String[] args) 
    {
        ExecutorService executor = Executors.newFixedThreadPool(100);
        for(int i = 0; i < 50; i++){
            executor.execute(new DeadlockTask1());
            executor.execute(new DeadlockTask2());
        }
        executor.shutdown();
        while(!executor.isTerminated()){
        
        }
        System.exit(0);
    }

    private static class DeadlockTask1 implements Runnable
    {
        public void run()
        {
            synchronized(locker1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("DeadlockTask1 获得锁 locker1");
                synchronized(locker2){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("DeadlockTask1 获得锁 locker2 没有死锁！");
                }
            }
        }
    }

    private static class DeadlockTask2 implements Runnable
    {
        public void run()
        {
            synchronized(locker1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("DeadlockTask2 获得锁 locker2");
                synchronized(locker2){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("DeadlockTask2 获得锁 locker1 没有死锁！");
                }
            }
        }
    }
    
}
View Code

 

转载于:https://www.cnblogs.com/RussellWestbrook/p/4256127.html

baicongbian4029
关注
线程同步练习:两个人同时访问一个账户,一个存款,另一个取款
qq_43788197的博客
06-08 1708
package day08; import java.util.Objects; /* 编程：假设一个银行的 ATM 机，它允许用户存款也可以取款。 现在一个账户(Account)上存款为 200 元， 用户 A 和用户 B 都拥有这个账户存款和取款的权利。 用户 A 存入 100 元，而用户 B 将取出 50 元， 则最终账户的存款应为 250 元。 为了模拟以上过程，描述如下： (1)定义一个 Account 类，属性为账户名(userName)和余额(bal...
java多线程：向银行账户存钱
li_w_ch的博客
04-08 1085
问题描述：100个线程同时向一个银行账户存入1元钱。 1：使用同步机制 银行账户类： /** * 银行账户类 * 演示100个线程同时向一个银行账户存入1元钱 * 未使用同步机制 */ public class Account { // 账户余额 private double balance; /** * 存款 * @param money : 存入金额 */ public synchronized void deposit(d
Java----线程协作的经典例子&生产者和消费者问题
weixin_30657999的博客
08-28 367
讲一瞎背景故事：创建并启动两个任务，一个用来向账户中存款，另一个从同一账户中提款。当提款的数额大于账户的当前余额时，提款线程必须等待。不管什么时候，只要向账户新存入一笔资金，存储线程必须通知提款线程重新常识。如果余额扔未达到提款的数额，提款线程必须继续等待新的存款。 再贴上一些相关的API图片 对于Condition的了解，我也不是很深。我觉得就是进程之...
学习笔记 java多线程（四）线程间协作
weixin_30782293的博客
04-26 162
通过保证在临界区上多个线程的相互排斥，线程间可以完全避免竞争状态的发生，但是有时候还是需要线程之间的相互协作。使用条件（Condition）便于线程间通信。一个线程可以指定在某种条件下该做什么。标间是通过调用Lock对象的newCoditionn（）方法来实现线程之间的相互通信的。 一旦创建一个条件，就可使用...
Java多线程并发编程技术详解
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 2万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
Java 多线程 测试
风信子
04-14 1944
Java 多线程 测试1 Callable2 Runnable3 Thread 1 Callable package com.xu.thread; import java.util.concurrent.Callable; /** * @author Administrator */ public class MyCallable implements Callable { @Override public Object call() throws Exception {
Java多线程(四)线程锁
yuanchun的知识整理
11-03 4697
Java多线程(四)线程锁
JAVA多线程基本原理
m0_58355200的博客
04-10 1874
JAVA多线程 1. 什么是线程?线程和进程的区别? 进程：进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当一个程序进入内存运行时，就成为一个进程。 线程：线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。它与父进程的其他线程共享该进程的所有资源。 主线程：在Java中必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束。
Java多线程（超详细）
loss_rose777的博客
08-14 2万+
25000字带你了解线程的概念，这一定是csdn上最全面的关于线程的文章，不看别后悔哦！
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Java-网络
最新发布
2301_81543552的博客
09-14 387
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 371
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 474
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 598
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值