JUC并发(1)

• 是否需要捕获异常

wait不需要，sleep必须捕获

2. 线程六大状态

3.lock锁

public class SaleTicketLock {

public static void main(String[] args) {

//创建资源类对象

Ticket ticket = new Ticket();

//创建线程

new Thread(() ->{

for (int i = 0; i < 40; i++) ticket.sale();},“A”).start();

new Thread(() ->{ for (int i = 0; i < 40; i++) ticket.sale(); },“B”).start();

new Thread(() ->{ for (int i = 0; i < 40; i++) ticket.sale(); },“C”).start();

}

}

//资源类

class Tickets{

private int number = 50;

//创建锁对象

Lock lock = new ReentrantLock();

//卖票的方式

public void sale(){

//加锁

lock.lock();

try {

if (number >0){

System.out.println(Thread.currentThread().getName()+“卖出了第”+(number–)+“张票剩余”+number);

}

} catch (Exception e) {

e.printStackTrace();

} finally {

//释放锁

lock.unlock();

}

}

}

synchronized和lock区别：

1. synchronize内置的java关键字，lock是一个java类

2. synchronize无法获取锁的状态，lock可以判断是否获取到了锁

3. 前者会自动释放锁，lock必须手动释放锁，如果不释放锁，会造成死锁

4. 前者线程1（获得锁，阻塞）线程2（等待，一直等）；lock就不一定会等待下去。lock.tryLock();

5. 前者可重入锁，不可以中断，非公平；lock，可重入锁，可以判断锁，非公平（可以自己设置）；

6. 前者锁少量的代码同步问题，lock适合锁大量的同步代码！

锁是什么？如何判断锁的是谁？

new this 具体的一个手机

static Class 唯一的一个模板

4.生产者，消费者问题

6、集合类不安全

package com.it;

import java.util.*;

import java.util.concurrent.CopyOnWriteArrayList;

// java.util.ConcurrentModificationException

public class Test {

public static void main(String[] args) {

//并发下ArrayList不安全

/*

• 解决方案：

• 1.List list = new Vector<>();

• 2. List list = Collections.synchronizedList(new ArrayList<>());

• 3.List list = new CopyOnWriteArrayList<>();

• CopyOnWrite写入时复制， COW 计算机程序设计领域的一种优化策略；

• 多个线程调用的时候，list，读取的时候固定的，写入时（覆盖）

• 在写入的时候避免覆盖，造成数据问题*/

List list = new CopyOnWriteArrayList<>();

//List list = new Vector<>();

for (int i = 0; i < 10; i++) {

new Thread(()->{

list.add(UUID.randomUUID().toString().substring(0,5));

System.out.println(list);

},String.valueOf(i)).start();

}

}

}

7、Callable

与Runbale区别：

1. 可以有返回值

2. 可以抛出异常

3. 方法不同，run（）/call()

package com.it.test;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

public class CallableTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

MyThread myThread = new MyThread();

//适配类

FutureTask futureTask = new FutureTask<>(myThread);

new Thread(futureTask,“A”).start();

new Thread(futureTask,“B”).start();//结果会被缓存

Integer o = (Integer) futureTask.get();//这个get可能会产生阻塞

System.out.println("o = " + o);