Java--多线程（下）

最新推荐文章于 2024-08-24 17:09:16 发布
最新推荐文章于 2024-08-24 17:09:16 发布
阅读量801 收藏 16
点赞数 14
分类专栏： Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77012210/article/details/141397753
版权

一、死锁*

1.1 概述

  • 当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。
  • 一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的钡怀记，由此可能造成死锁。

1.2 代码实现

public class Demo01 {
    public static void main(String[] args) {
        /**
         *  创建类
         *      测试类
         *      锁对象
         *          存储两个锁
         *      线程BB
         *      线程CC
         */
        // 创建创建
        ThreadBB bb = new ThreadBB();
        ThreadCC cc = new ThreadCC();
        
        // 开启线程
        bb.start();
        cc.start();
        
    }
}

class LockObject {
    public static final Object LOCK_A = new Object();
    public static final Object LOCK_B = new Object();
}

class ThreadBB extends Thread {
    @Override
    public void run() {
        synchronized (LockObject.LOCK_A) {
            System.out.println("BB获取到第一根筷子LOCK_A,正在尝试获取第二根筷子LOCK_B");
            synchronized (LockObject.LOCK_B) {
                System.out.println("BB获取到筷子LOCK_A和筷子LOCK_B,可以开动啦");
            }
        }
    }
}

class ThreadCC extends Thread {
    @Override
    public void run() {
        synchronized (LockObject.LOCK_B) {
            System.out.println("CC获取到第一根筷子LOCK_B,正在尝试获取第二根筷子LOCK_A");
            synchronized (LockObject.LOCK_A) {
                System.out.println("CC获取到筷子LOCK_A和筷子LOCK_B,可以开动啦");
            }
        }
    }
}

二、生产者和消费者

2.1 概述

  • 若干个生产者在生产产品，这些产品将提供给若干个消费者去消费
  • 为了使生产者和消费者能并发执行，在两者之间设置一个能存储多个产品的缓冲区
  • 生产者将生产的产品放入缓冲区中，消费者从缓冲区中取走产品进行消费
  • 显然生产者和消费者之间必须保持同步
    • 即不允许消费者到一个空的缓冲区中取产品
    • 也不允许生产者向一个满的缓冲区中放入产品。

2.2 第一版

  • 线程安全问题
  • 顺序问题
public class Demo01 {
    public static void main(String[] args) {
        /**
         * 测试类
         * 
         * 线程BB
         * 线程CC
         */
        // 创建对象
        Card card = new Card();
        ThreadBB bb = new ThreadBB(card);
        ThreadCC cc = new ThreadCC(card);
        
        // 开启线程
        bb.start();
        cc.start();
    }
}


class Card {
    private int money = 0;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
    
}

class ThreadBB extends Thread {
    
    private Card card;
    
    public ThreadBB(Card card) {
        super();
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 12; i++) {
            card.setMoney(card.getMoney()-5000);
            System.out.println("BB取出了5000,余额" + card.getMoney());
        }
    }
}

class ThreadCC extends Thread {
    
    private Card card;
    
    public ThreadCC(Card card) {
        super();
        this.card = card;
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= 12; i++) {
            card.setMoney(card.getMoney()+5000);
            System.out.println("CC存入了5000,余额" + card.getMoney());
        }
    }
}

2.3 第二版

  • 线程之间无通讯,使用i–的方式处理无法执行的线程
public class Demo01 {
    public static void main(String[] args) {
        /**
         * 测试类
         * 
         * 线程BB
         * 线程CC
         */
        // 创建对象
        Card card = new Card();
        ThreadBB bb = new ThreadBB(card);
        ThreadCC cc = new ThreadCC(card);
        
        // 开启线程
        bb.start();
        cc.start();
    }
}


class Card {
    private int money = 0;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
    
}

class ThreadBB extends Thread {
    
    private Card card;
    
    public ThreadBB(Card card) {
        super();
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 12; i++) {
            synchronized (Card.class) {
                if (card.getMoney() <= 0) {
                    i--;
                    continue;
                }
                card.setMoney(card.getMoney()-5000);
                System.out.println("BB取出了5000,余额" + card.getMoney());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class ThreadCC extends Thread {
    
    private Card card;
    
    public ThreadCC(Card card) {
        super();
        this.card = card;
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= 12; i++) {
            if (card.getMoney() > 0) {
                i--;
                continue;
            }
            synchronized (Card.class) {
                card.setMoney(card.getMoney()+5000);
                System.out.println("CC存入了5000,余额" + card.getMoney());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.4 第三版

  • 采用线程通讯方式交替执行
public class Demo01 {
    public static void main(String[] args) {
        /**
         * 测试类
         * 
         * 线程BB
         * 线程CC
         */
        // 创建对象
        Card card = new Card();
        ThreadBB bb = new ThreadBB(card);
        ThreadCC cc = new ThreadCC(card);
        
        // 开启线程
        bb.start();
        cc.start();
    }
}


class Card {
    private int money = 0;

    /**
     *  存款方法
     *      CC操作存款方法
     *      如果money>0,CC线程等待,通知BB线程执行
     *      如果money<=0,CC线程执行
     */
    public synchronized void saveMoney() {
        if (money > 0) {
            try {
                // money>0,线程等待
                this.wait();
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        // 如果代码执行到这里说明money<=0
        money += 5000;
        System.out.println("CC存入了5000,余额" + money);
        // 已经存入,通知BB执行
        this.notify();
    }
    
    /**
     * 取款方法
     *      BB线程执行
     *      如果money>0,BB线程执行
     *      如果money<=0,BB线程等待,通知CC线程执行
     */
    public synchronized void takeMoney() {
        // 判定是否有余额
        if (money <= 0) {
            // 卡里空了
            try {
                this.wait();
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        // 如果代码执行到这里,money>0
        money -= 5000;
        System.out.println("BB取出了5000,余额" + money);
        // 已经取出,通知CC执行
        this.notify();
    }
    
}

class ThreadBB extends Thread {
    
    private Card card;
    
    public ThreadBB(Card card) {
        super();
        this.card = card;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 12; i++) {
            card.takeMoney();
        }
    }
}

class ThreadCC extends Thread {
    
    private Card card;
    
    public ThreadCC(Card card) {
        super();
        this.card = card;
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= 12; i++) {
            card.saveMoney();
        }
    }
}

三、线程池

3.1 概述

  • 线程的创建和销毁会占用大量的资源
    • 内存
    • 处理器
  • 可以限制线程创建的数量，复用创建的线程，把线程放入一个容器

3.2 线程池入门

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

public class Demo02 {
    public static void main(String[] args) throws InterruptedException {
        // 创建线程池对象
        ExecutorService es = Executors.newFixedThreadPool(2);
        
        // 提交任务
        es.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "==>" + i);
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        
        es.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "==>" + i);
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        
        es.submit(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "==>" + i);
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        
        // 启用顺序关闭:运行结束的线程退出任务
        es.shutdown();
        System.out.println(es);
        
        Thread.sleep(3000);
        System.out.println(es);
    }
}

3.3 线程池API

Executor
  • 线程池的顶层接口
  • 执行已提交的 Runnable 任务的对象。
ExecutorService
  • 声明的线程池对象类型
  • 有子类ThreadPoolExecutor
 boolean isTerminated() 
          如果关闭后所有任务都已完成，则返回 true。 
 void shutdown() 
          启动一次顺序关闭，执行以前提交的任务，但不接受新任务。 
<T> Future<T>  submit(Callable<T> task) 
          提交一个返回值的任务用于执行，返回一个表示任务结果的 Future。 
 Future<?> submit(Runnable task) 
          提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
Executors
  • Executors 类为这些 Executor 提供了便捷的工厂方法。
  • 创建线程池对象
static ExecutorService newCachedThreadPool() 
          创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。 
static ExecutorService newFixedThreadPool(int nThreads) 
          创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。 
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 
          创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。 
static ExecutorService newSingleThreadExecutor() 
          创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
Callable
  • 返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。
  • Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。
  • 但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。
Future
  • Future 表示异步计算的结果。
  • 它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。
  • 计算完成后只能使用 get 方法来获取结果
    • 如有必要，计算完成前可以阻塞此方法。

3.4 多线程计算数组总和【掌握】

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Demo06 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        /**
         * 有一个二维数组，长度是4，使用多线程计算所有元素的总和【考题】
         */
        // 创建数组
        int[][] arr = {
                {12,565,98,2,4,67,8,322,657,97,656},
                {9,766,5,456,67,8,78,8,34,343,37632},
                {42314,7,3,76,1356763,45,85,464},
                {7633,24,876432,8,7434,5765,323,46,5}
        };
        // 创建线程池
        ExecutorService es = Executors.newFixedThreadPool(4);
        
        // 提交任务
        Future<Integer> future00 = es.submit(new CalculatCallable(arr[0]));
        Future<Integer> future01 = es.submit(new CalculatCallable(arr[1]));
        Future<Integer> future02 = es.submit(new CalculatCallable(arr[2]));
        Future<Integer> future03 = es.submit(new CalculatCallable(arr[3]));
        
        // 启动顺序关闭
        es.shutdown();
        
        // 输出计算结果
        System.out.println(future00.get() + future01.get() + future02.get() + future03.get());
        System.out.println(39406+2488+1399757+897670);
    }
}

/**
 * 创建任务线程类
 *  计算指定数组中所有元素的总和
 */
class CalculatCallable implements Callable<Integer>{
    
    private int[] arr;
    
    public CalculatCallable(int[] arr) {
        super();
        this.arr = arr;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}

四、Lock

4.1 概述

  • Lock 提供了比使用 synchronized 方法和语句更广泛的锁定操作。
    • 能实现synchronized的所有参数
    • 更加的灵活、高效

4.2 核心方法

lock
	锁定
unLock
	解锁，必须执行，放在finally代码块中执行

4.3 ReentrantLock

  • 一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。
  • 可重入
    • 可以多次执行
  • 互斥
    • A线程执行的时候B线程阻塞
    • B线程执行的时候A线程阻塞
  • 卖票
import java.util.concurrent.locks.ReentrantLock;

public class Demo01 {
	public static void main(String[] args) {
		/**
		 *	火车站四个窗口,共同卖出100张车票,用多线程实现。
		 */
		// 创建线程
		TicketThread t01 = new TicketThread();
		TicketThread t02 = new TicketThread();
		TicketThread t03 = new TicketThread();
		TicketThread t04 = new TicketThread();
		
		// 设置名字
		t01.setName("一号窗口");
		t02.setName("22号窗口");
		t03.setName("叁号窗口");
		t04.setName("④号窗口");
		
		// 启动线程
		t01.start();
		t02.start();
		t03.start();
		t04.start();
		
	}
}

class TicketThread extends Thread {
	private static int ticket = 100;
	// 创建互斥锁
	private static ReentrantLock lock = new ReentrantLock();
	@Override
	public void run() {
		while (true) {
			// 上锁
			lock.lock();
			try {
				if (ticket <= 0) {
					break;
				}
				ticket--;
				System.out.println(Thread.currentThread().getName() + "卖出了第" + (100 - ticket) + "张票,还剩下" + ticket);
			} finally {
				// 解锁
				lock.unlock();
			}
		}
	}
}
  • 数组
import java.util.Arrays;
import java.util.concurrent.locks.ReentrantLock;

public class Demo02 {
	public static void main(String[] args) throws InterruptedException {
		/**
		 *	创建类
		 *		测试类
		 *		数组资源类
		 *			数组
		 *			索引
		 *		线程A	
		 *			存入Hello
		 *		线程B
		 *			存入World
		 */
		// 创建数组和索引
		ArrSrc arrSrc = new ArrSrc();
		// 创建线程A和B
		ThreadA a = new ThreadA(arrSrc);
		ThreadB b = new ThreadB(arrSrc);
		
		// 启动线程修改数组
		a.start();
		b.start();
		
		// main线程休眠,等待线程a和b执行结束之后再看修改之后的结果
		Thread.sleep(10);
		// 输出修改之后的数组
		System.out.println(arrSrc);
	}
}


/**
 *	数组资源
 */
class ArrSrc {
	String[] arr = new String[5];
	int index = 0;
	private static ReentrantLock lock = new ReentrantLock();
	
	/**
	 * 修改数组的方法
	 * 	修改数组数据
	 * 	索引自增
	 * @param str
	 */
	public void modifyArr(String str) {
		lock.lock();
		try {
			arr[index] = str;
			index++;
		} finally {
			lock.unlock();
		}
	}

	@Override
	public String toString() {
		return "ArrSrc [arr=" + Arrays.toString(arr) + ", index=" + index + "]";
	}

}

class ThreadA extends Thread {
	private ArrSrc arrSrc;
	
	public ThreadA(ArrSrc arrSrc) {
		super();
		this.arrSrc = arrSrc;
	}

	@Override
	public void run() {
		arrSrc.modifyArr("Hello");
	}
}

class ThreadB extends Thread {
	private ArrSrc arrSrc;
	
	public ThreadB(ArrSrc arrSrc) {
		super();
		this.arrSrc = arrSrc;
	}

	@Override
	public void run() {
		arrSrc.modifyArr("World");
	}
}

4.4 读写锁

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class Demo03 {
	public static void main(String[] args) {
		
		MyClass mc = new MyClass();
		long startTime = System.currentTimeMillis();
		
		// 创建线程池,容量20【18读 + 2写】
		ExecutorService es = Executors.newFixedThreadPool(20);
		
		// 提交任务:读取数据*18
		for (int i = 0; i < 18; i++) {
			es.submit(new Runnable() {
				@Override
				public void run() {
					mc.getValue();
				}
			});
		}
		
		// 提交任务:写入数据*2
		for (int i = 0; i < 2; i++) {
			es.submit(new Runnable() {
				@Override
				public void run() {
					mc.setValue("Hello");
				}
			});
		}
		es.shutdown();
		
		// 阻塞:判定线程池中任务是否全部完成
		while (!es.isTerminated()) {}
		long endTime = System.currentTimeMillis();
		System.out.println(endTime - startTime);
		
	}
}

class MyClass {
	// 创建互斥锁
	private ReentrantLock lock = new ReentrantLock();
	// 创建读写锁
	private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
	// 获取读锁
	ReadLock readLock = readWriteLock.readLock();
	// 获取写锁
	WriteLock writeLock = readWriteLock.writeLock();
	
	private String value;

	/**
	 * 读取数据
	 * @return
	 */
	public String getValue() {
		// lock.lock();
		readLock.lock();
		try {
			Thread.sleep(1000);
			return value;
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			// lock.unlock();
			readLock.unlock();
		}
		return value;
	}

	/**
	 * 写入数据
	 * @param value
	 */
	public void setValue(String value) {
		//lock.lock();
		writeLock.lock();
		try {
			this.value = value;
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			//lock.unlock();
			writeLock.unlock();
		}
	}
	
}
一只勤劳的小蜜蜂Yy
关注
  • 14
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
 jmu-Java-07多线程-同步访问 (10分)
嗯呢嗯呢的博客
06-06 6169
jmu-Java-07多线程-同步访问(10分) 现已有Account类，拥有属性:private int balance方法: 相应的getter方法。 要求为该类编写：void deposit(int money)//存钱，在余额的基础上加上moneyvoid withdraw(int money)//取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。 需要编写完...
12jmu-Java-07多线程-Thread
ihopeyousuccess的博客
11-30 2027
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
013jmu-Java-07多线程-PrintTask
ihopeyousuccess的博客
11-30 4738
编写PrintTask类实现Runnable接口。 功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即PrintTask类的代码/ public class Main { public static void main(String[] args) { Scann
PTA- jmu-Java-07多线程-交替执行
m0_62565675的博客
12-28 1380
PTA-Java-07多线程-交替执行
jmu-Java-07多线程-Runnable与停止线程
LHMandHH999的博客
01-04 1449
jmu-Java-07多线程-Runnable与停止线程
6-6 jmu-Java-07多线程-同步访问 (10 分)
m0_54524462的博客
12-02 3278
6-6 jmu-Java-07多线程-同步访问 (10 分) 现已有Account类，拥有 属性: private int balance 方法: 相应的getter方法。 要求为该类编写： void deposit(int money) //存钱，在余额的基础上加上money void withdraw(int money) //取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。
java -xss_Java线程与Xss
weixin_31302909的博客
02-12 3788
jvm系列Xss与线程个数Xss越大，每个线程的大小就越大，占用的内存越多，能容纳的线程就越少；Xss越小，则递归的深度越小，容易出现栈溢出 java.lang.StackOverflowError。减少局部变量的声明，可以节省栈帧大小，增加调用深度。/*** -Xss128K deep of calling = 675* -Xss256K deep of calling = 1686*...
jmu-Java-07多线程-Runnable与匿名类
qq_hua_xia的博客
10-27 1184
题目详情： 6-1 jmu-Java-07多线程-Runnable与匿名类 (10 分) 在Main方法中启动一个线程t1，该线程输出3行信息： 主线程名 线程t1的线程名 线程t1所实现的所有接口。提示：使用System.out.println(Arrays.toString(getClass().getInterfaces()));输出。 注：本题也可使用Lambda表达式实现。 裁判测试程序： public class Main { public static void
Java多线程-CountDownLatch
weixin_45203607的博客
02-16 2591
介绍 CountDownLatch是一个同步辅助类，它允许一个或多个线程一直等待直到其他线程执行完毕才开始执行。 用给定的计数初始化CountDownLatch，其含义是要被等待执行完的线程个数。 每次调用CountDown()，计数减1 主程序执行到await()函数会阻塞等待线程的执行，直到计数为0 场景 1:多线程读取批量文件, 并且读取完成之后汇总处理 2:多线程读取Excel多个sheet,读取完成之后获取汇总获取的结果 3:多个人一起一起来吃饭,主人等待客人到来,客人一个个从不同地方来到饭店,主
Java多线程超详解
热门推荐
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
JAVA-多线程 所有文件
01-09
这个“JAVA-多线程 所有文件”压缩包很可能包含了一系列关于Java多线程学习的源代码示例和相关文档。下面我们将深入探讨Java多线程的相关知识点。 1. **线程的概念**：线程是操作系统分配CPU时间的基本单位，一个...
java课件-5-多线程
01-10
总之，Java多线程编程是一个深度和广度都非常大的主题，涵盖了从基础的线程创建到复杂的并发控制策略，理解并熟练掌握这些知识对于编写高效、可靠的并发Java应用程序具有决定性的影响。通过学习提供的课件和实战练习...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶 Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC...
Java-REST-SOAP-AeroSpike-多线程
02-11
总之，这个主题覆盖了Java多线程编程、REST和SOAP服务的创建、以及AeroSpike数据库的使用，这些都是现代软件开发中的重要技术。理解和掌握这些知识点，对于提升Java开发者在企业级应用开发中的技能和竞争力至关重要...
Java-多线程线程状态转换图
07-22
多线程线程状态转换图
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 504
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 766
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1043
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
最新发布
寂夜了无痕的博客
08-24 707
linux上datax 安装以及使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值