简述Java多线程(二)

时间:2024-04-03 23:04:20

Java多线程(二)

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行。

简述Java多线程(二)

优先级高的不一定先执行,大多数情况是这样的。

优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调度了。

优先级的设定建议在start()调度前,setPriority之后紧接start()

守护线程_daemon

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 例子:后台记录操作日志,监控内存,垃圾回收等待等
thread.setDaemon(true);//默认false表示是用户线程

thread即使是永远运行,也会结束,因为是守护线程,JVM不会等待,用户线程结束之后即结束。

线程同步

多个线程操作同一个资源。每个线程在自己的工作内存交互,内存控制不当会造成数据不一致。

由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用后释放锁即可。存在以下问题:

  • 一个线程持有锁会导致其他所有需要此锁的线程挂起
  • 在多线程竞争下,加锁、释放锁会导致比较多的上下文切换和调度延时,引起性能问题
  • 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题

不安全案例:(ArrayList是线程不安全的)

public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
System.out.println(list.size());
}

简述Java多线程(二)

可能的原因:1.可能有些线程还在执行时,就输出了size() 2.某个瞬间,往list同一位置添加了两次覆盖了

同步方法及同步块

同步方法: synchronized默认锁的是this这个对象本身(后续反射章节会有涉及)

public synchronized void method(int args){}

同步块:synchronized(obj){}

简述Java多线程(二)

举例一个不安全银行取钱的例子:

public class TestAccount {
public static void main(String[] args) throws InterruptedException {
Account account = new Account("sum",100);
Drawing you = new Drawing(account,50,"you");
Drawing girlfriend = new Drawing(account,70,"girl");
new Thread(you).start();
new Thread(girlfriend).start();
}
} class Account{
String name;
int Money;
public Account(String name,int money){
this.Money=money;
this.name=name;
}
} class Drawing implements Runnable{
Account account;
int drawingMoney;
int nowMoney=0;
String name; public Drawing(Account account,int drawingMoney, String name) {
this.account = account;
this.drawingMoney = drawingMoney;
this.name = name;
} @Override
public void run() {
if(account.Money-drawingMoney < 0){
System.out.println("there's no money");
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.Money = account.Money - drawingMoney;
nowMoney = nowMoney+drawingMoney;
System.out.println("bank remains "+account.Money);
System.out.println(name+" get "+nowMoney);
}
}

结果如下:

简述Java多线程(二)

银行没有判断出钱不够,这里的sleep放大了事故可能性。

增加同步块:

@Override
public void run() {
synchronized (account){
if(account.Money-drawingMoney < 0){
System.out.println("there's no money");
return ;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.Money = account.Money - drawingMoney;
nowMoney = nowMoney+drawingMoney;
System.out.println(name+" get "+nowMoney);
System.out.println("bank remains "+account.Money);
}
}

共同操作的是account所以obj即为它,同步块里即为原来的方法块,可以锁任何对象(需要锁操作的共同资源对象),这是和synchronized方法不同之处。

用该方法改进上方的不安全ArrayList

public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
Thread.sleep(1000);
System.out.println(list.size());
}

输出即为1000。

提一下并发编程中的安全List(CopyOnWriteArrayList

public static void main(String[] args) throws InterruptedException {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
Thread.sleep(5000);
System.out.println(list.size());
}

这里的List是线程安全的。

死锁

多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源释放才能运行。某个同步块同时拥有“两个以上对象的锁”时,就可能发生死锁。

补充:synchronized(obj){}其实可以理解为等待obj释放锁之后执行代码块

产生死锁的四个必要条件:

  • 互斥条件:一个资源每次只能被一个进程使用
  • 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放
  • 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺
  • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系(例:A等B拿的资源,B等A拿的资源)

Lock锁

JDK5.0开始,提供了更强大的线程同步机制,通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。

java.util.concurrent.locks.lock接口是控制多个线程对共享资源进行访问的工具。ReentrantLockLock的常用实现类(可重入锁)。

class TestLock2 implements Runnable{

    int ticketNums = 10;
private final ReentrantLock lock = new ReentrantLock(); @Override
public void run() {
while(true){
try {
lock.lock();//加锁
if(ticketNums>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
}else{
break;
}
} finally { //解锁
lock.unlock();
} }
}
}

仍然是抢票举例,.lock()加锁,.unlock()解锁,以上结果没有冲突情况。

简述Java多线程(二)

线程协作(生产者消费者问题)

在这个问题中,仅用synchronized是不够的

  • synchronized可阻止并发更新同一个共享资源,实现了同步
  • synchronized不能用来实现不同线程之间的通信

简述Java多线程(二)

解决方式1:管程法

public class TestPC {   //利用缓冲区解决
public static void main(String[] args) {
Buffer buffer = new Buffer();
new Producer(buffer).start();
new Consumer(buffer).start();
}
} class Producer extends Thread{
Buffer buffer;
public Producer(Buffer buffer){
this.buffer = buffer;
} @Override
public void run() {
for (int i = 1; i < 100; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
buffer.push(new product(i));
System.out.println("生产了第"+i+"个产品");
}
}
} class Consumer extends Thread{
Buffer buffer;
public Consumer(Buffer buffer){
this.buffer = buffer;
} @Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("消费了第"+buffer.pop().id+"个产品");
}
}
} class product{
int id; public product(int id) {
this.id = id;
}
} class Buffer{
product[] pro = new product[10]; //缓存区大小
int count=0;
public synchronized void push(product p){
if(count == pro.length){
//通知等待消费
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
pro[count] = p;
count++; //通知可以消费了
this.notifyAll();
} public synchronized product pop() {
if (count == 0) {
//等待生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count--;
product p2 = pro[count];
this.notifyAll();
return p2;
}
}

此段代码只涉及了新的wait()notifyAll(),其余过程和操作系统相关知识描述一致,可以理一下思路。

解决方式2:信号灯法(利用标志位)建立一个(true,false)标志位进行判断,操作系统相关知识已有,不再详细描述

线程池

背景:经常创建和销毁,使用量特别大

思路:提前创建好多个线程,放在线程池中,使用时直接获取,使用完放回池中,可以避免频繁创建销毁,实现重复利用。

好处:

  • 提高响应速度(减少了创建新线程的时间)
  • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
  • 便于线程管理

corePoolSize:核心池大小

maximumPoolSize:最大线程数

keepAliveTime:线程没有任务时最多保持多长时间后会终止

简述Java多线程(二)

简单举例:

public class TestPool {
public static void main(String[] args) {
//创建服务,创建线程池
ExecutorService service = Executors.newFixedThreadPool(10); //执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread()); //关闭链接
service.shutdown();
}
} class MyThread implements Runnable{ @Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}

线程池相关知识将在并发编程部分详细介绍。