JUC并发编程(5.Java线程）

深藏阁楼爱情的钟 2023-09-23 23:11 47阅读 0赞

# 1.常见线程安全类String #

*  Integer
 *  StringBuffer
 *  Random
 *  Vector
 *  Hashtable
 *  java.util.concurrent包下的类

这里说它们是线程安全的是指，**多个线程调用它们同一个实例的某个方法时，是线程安全的**。也可以理解为它们的每个方法是原子的但注意它们多个方法的组合不是原子的

Hashtable table = new Hashtable();
    new Thread(()->{
        
    table.put("key", "value1");
    }).start();
    new Thread(()->{
        
    table.put("key", "value2");
    }).start();

## 1.1线程安全类方法的组合 ##

Hashtable table = new Hashtable();
    // 线程1，线程2
    if( table.get("key") == null) {
        
    	table.put("key", value);
    }

![在这里插入图片描述][cecef3095edc4a7e93b66955fafaaa22.png]

## 1.2 不可变类线程安全性 ##

String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的有同学或许有疑问，String 有 replace，substring 等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢？

看源代码发现没有改变字符，所以线程是安全的

Hashtable table = new Hashtable();
    // 线程1，线程2
    if( table.get("key") == null) {
        
    	table.put("key", value);
    }

public class Immutable{
        
    	private int value = 0;
    	public Immutable(int value){
        
    		this.value = value;
    	}
    	public int getValue(){
        
    		return this.value;
    	}
    }

public class Immutable{
        
    	private int value = 0;
    	public Immutable(int value){
        
    		this.value = value;
    	}
    	public int getValue(){
        
    		return this.value;
    	}
    	public Immutable add(int v){
        
    		return new Immutable(this.value + v);
    	}
    }

实例分析1

public class MyServlet extends HttpServlet {
        
    	// 是否安全？不是
    	Map<String,Object> map = new HashMap<>();
    	// 是否安全？是
    	String S1 = "...";
    	// 是否安全？是
    	final String S2 = "...";
    	// 是否安全？不是，常见类型没有它
    	Date D1 = new Date();
    	// 是否安全？不能保证，引用不可便，但属性可修改
    	final Date D2 = new Date();
    	public void doGet(HttpServletRequest request, HttpServletResponse response) {
        
    	// 使用上述变量
    	}
    }

例2：

public class MyServlet extends HttpServlet {
        
    	// 是否安全？ 不是，多个线程可能调用它
    	private UserService userService = new UserServiceImpl();
    	public void doGet(HttpServletRequest request, HttpServletResponse response) {
        
    		userService.update(...);
    	}
    	}
    	public class UserServiceImpl implements UserService {
        
    	// 记录调用次数
    	private int count = 0;
    	public void update() {
        
    	// ...
    	count++;
    	}
    }

例3：

@Aspect
    @Component
    public class MyAspect {
        
    	// 是否安全？有线程安全问题，用环绕通知做成局部变量
    	private long start = 0L;
    	@Before("execution(* *(..))")
    	public void before() {
        
    		start = System.nanoTime();
    	}
    	@After("execution(* *(..))")
    	public void after() {
        
    		long end = System.nanoTime();
    		System.out.println("cost time:" + (end-start));
    	}
    }

例4：

public class MyServlet extends HttpServlet {
        
    // 是否安全 是安全的
    	private UserService userService = new UserServiceImpl();
    	public void doGet(HttpServletRequest request, HttpServletResponse response) {
        
    		userService.update(...);
    	}
    	}
    	public class UserServiceImpl implements UserService {
        
    	// 是否安全  是，局部变量
    	private UserDao userDao = new UserDaoImpl();
    	public void update() {
        
    		userDao.update();
    		}
    	}
    	public class UserDaoImpl implements UserDao {
        
    	public void update() {
        
    	String sql = "update user set password = ? where username = ?";
    	// 是否安全 是，方法的局部变量
    	try (Connection conn = DriverManager.getConnection("","","")){
        
    	// ...
    	} catch (Exception e) {
        
    	// ...
    	}
    	}
    }

例5：

public class MyServlet extends HttpServlet {
        
    	// 是否安全
    	private UserService userService = new UserServiceImpl();
    	public void doGet(HttpServletRequest request, HttpServletResponse response) {
        
    		userService.update(...);
    	}
    }
    public class UserServiceImpl implements UserService {
        
    	// 是否安全
    	private UserDao userDao = new UserDaoImpl();
    	public void update() {
        
    		userDao.update();
    	}
    }

public class UserDaoImpl implements UserDao {
        
    	// 是否安全 不是，要做成局部私有的成员变量
    	private Connection conn = null;
    	public void update() throws SQLException {
        
    	String sql = "update user set password = ? where username = ?";
    	conn = DriverManager.getConnection("","","");
    	// ...
    	conn.close();
    	}
    }

例6：

public class MyServlet extends HttpServlet {
        
    	// 是否安全 没有，方法的局部变量
    	private UserService userService = new UserServiceImpl();
    	public void doGet(HttpServletRequest request, HttpServletResponse response) {
        
    	userService.update(...);
    	}
    }
    public class UserServiceImpl implements UserService {
        
    	public void update() {
        
    		UserDao userDao = new UserDaoImpl();
    		userDao.update();
    	}
    }
    public class UserDaoImpl implements UserDao {
        
    	// 是否安全 没有
    	private Connection = null;
    	public void update() throws SQLException {
        
    		String sql = "update user set password = ? where username = ?";
    		conn = DriverManager.getConnection("","","");
    		// ...
    		conn.close();
    	}
    }

例7：

public abstract class Test {
        
    	public void bar() {
        
    	// 是否安全  不是 局部变量，传给抽象方法的foo
    	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	foo(sdf);
    	}
    	public abstract foo(SimpleDateFormat sdf);
    		public static void main(String[] args) {
        
    		new Test().bar();
    	}
    }

public void foo(SimpleDateFormat sdf) {
        
    	String dateStr = "1999-10-11 00:00:00";
    	for (int i = 0; i < 20; i++) {
        
    		new Thread(() -> {
        
    		try {
        
    			sdf.parse(dateStr);
    		} catch (ParseException e) {
        
    			e.printStackTrace();
    		}
    		}).start();
    	}
    }

例8：

private static Integer i = 0;
    public static void main(String[] args) throws InterruptedException {
        
    	List<Thread> list = new ArrayList<>();
    	for (int j = 0; j < 2; j++) {
        
    		Thread thread = new Thread(() -> {
        
    		for (int k = 0; k < 5000; k++) {
        
    			synchronized (i) {
        
    			i++;
    		}
    	}
    	}, "" + j);
    	list.add(thread);
    	}
    	list.stream().forEach(t -> t.start());
    	list.stream().forEach(t -> {
        
    		try {
        
    			t.join();
    		} catch (InterruptedException e) {
        
    			e.printStackTrace();
    		}
    		});
    	log.debug("{}", i);
    	}

### 买票的线程安全问题 ###

public class ExerciseSell {
        
        public static void main(String[] args) throws InterruptedException {
        
            // 模拟多人买票
            TicketWindow window = new TicketWindow(1000);
    
            // 所有线程的集合
            List<Thread> threadList = new ArrayList<>();
            // 卖出的票数统计
            List<Integer> amountList = new Vector<>();
            for (int i = 0; i < 2000; i++) {
        
                Thread thread = new Thread(() -> {
        
                    // 买票
                    int amount = window.sell(random(5));
                    // 统计买票数
                    amountList.add(amount);
                });
                threadList.add(thread);
                thread.start();
            }
    
            for (Thread thread : threadList) {
        
                thread.join();
            }
    
            // 统计卖出的票数和剩余票数
            log.debug("余票：{}",window.getCount());
            log.debug("卖出的票数：{}", amountList.stream().mapToInt(i-> i).sum());
        }
    
        // Random 为线程安全
        static Random random = new Random();
    
        // 随机 1~5
        public static int random(int amount) {
        
            return random.nextInt(amount) + 1;
        }
    }
    
    // 售票窗口
    class TicketWindow {
        
        private int count;
    
        public TicketWindow(int count) {
        
            this.count = count;
        }
    
        // 获取余票数量
        public int getCount() {
        
            return count;
        }
    
        // 售票
        public synchronized int sell(int amount) {
        
            if (this.count >= amount) {
        
                this.count -= amount;
                return amount;
            } else {
        
                return 0;
            }
        }
    }

10:13:41.629 c.ExerciseSell [main] - 余票：0
    10:13:41.635 c.ExerciseSell [main] - 卖出的票数：1000

### 转账的线程安全问题 ###

public class ExerciseTransfer {
        
        public static void main(String[] args) throws InterruptedException {
        
            Account a = new Account(1000);
            Account b = new Account(1000);
            Thread t1 = new Thread(() -> {
        
                for (int i = 0; i < 1000; i++) {
        
                    a.transfer(b, randomAmount());
                }
            }, "t1");
            Thread t2 = new Thread(() -> {
        
                for (int i = 0; i < 1000; i++) {
        
                    b.transfer(a, randomAmount());
                }
            }, "t2");
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            // 查看转账2000次后的总金额
            log.debug("total:{}", (a.getMoney() + b.getMoney()));
        }
    
        // Random 为线程安全
        static Random random = new Random();
    
        // 随机 1~100
        public static int randomAmount() {
        
            return random.nextInt(100) + 1;
        }
    }
    
    // 账户
    class Account {
        
        private int money;
    
        public Account(int money) {
        
            this.money = money;
        }
    
        public int getMoney() {
        
            return money;
        }
    
        public void setMoney(int money) {
        
            this.money = money;
        }
    
        // 转账
        public void transfer(Account target, int amount) {
        
            synchronized(Account.class) {
        
                if (this.money >= amount) {
        
                    this.setMoney(this.getMoney() - amount);
                    target.setMoney(target.getMoney() + amount);
                }
            }
        }
    }

10:15:22.900 c.ExerciseTransfer [main] - total:2000

# 2.Monitor概念 #

![在这里插入图片描述][41c98d423253486fb11663ddc06b08c6.png]

*  刚开始Monitor中Owner为null
 *  当Thread-2执行synchronized(obj)就会将Monitor的所有者Owner设置为Thread-2，Monitor中只能有一个Owner。
 *  在Thread-2上锁的过程中，如果Thread-3，Thread-4，Thread-5也来执行synchronized(obj)就会进入EntryList BLOCKED
 *  Thread-2执行完同步代码块的内容，然后唤醒EntryList 中等待的线程来竞争锁，竞争的时候是非公平的
 *  WaitSet中的Thread-0，Thread-1是之前获得过锁，但条件不满足进入WAITING状态的线程，后面wait-notify时会分析  
    注意：
 *  synchronized**必须是进入同一个对象**monitor才有上述的效果
 *  **不加synchronized的对象不会关联监视器，不遵循以上规则**

# 3.Synchronized原理 #

## 3.1轻量级锁 ##

轻量级锁的使用场景：  
如果一个对象虽然有多线程访问，但多线程访问的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化

*  轻量级锁对使用者是同名的，语法是synchronized
 *  假设有两个方法同步，利用同一个对象加锁

static final Object obj = new Object();
    public static void method1(){
        
    	synchronized（obj){
        
    		//同步块A
    		method2();
    	}
    }
    public static void method1(){
        
    	synchronized（obj){
        
    		//同步块B
    	}
    }

*  创建锁记录（Lock Record) 对象，每个线程的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
 *

![在这里插入图片描述][6a3a6a0a10064aea93369387a664a54d.png]

*  让锁记录中Object reference指向对象，并尝试用cas替换Object的Mark Word，将Mark Word的值存入锁记录  
    ![在这里插入图片描述][d1ee03d651994ff7b5261fd67c0a29f9.png]
 *  如果cas替换成功，对象头中存储了锁记录地址和状态00，表示由该线程给对象加锁  
    ![在这里插入图片描述][ba5894aed0d7483fbbe50955214d25e9.png]
 *  如果cas失败，有两种情况
    
     *  如果是其他线程已经持有了该Object的轻量级锁，这时表明有竞争， 进入锁膨胀过程
     *  如果是自己执行了synchronized锁重入，那么再添加一条Lock Record作为重入计数

![在这里插入图片描述][6838d38004444239acde4e04b9b67337.png]

*  当退出synchronized代码块（解锁时）如果有取值为null的记录，表示冲入，这是重置锁记录，表示重入计数减一  
    ![在这里插入图片描述][dfd2277c39b346869d3fb4862699c955.png]
 *  当退出synchronized代码块（解锁时）如果有取值不为null，这是使用cas将Mark Word的值恢复给对象头
    
     *  成功，解锁成功
     *  失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重置级锁解锁流程

## 3.2 锁膨胀 ##

*  如果再尝试加轻量级锁的过程中，CAS操作无法成功，这是一中情况就是其他线程为此对象加上了轻量级锁（有竞争了），需要进行锁膨胀，将轻量级锁变位重量级锁

static final Object obj = new Object();
    public static void method1(){
        
    	synchronized（obj){
        
    		//同步块
    	}
    }

*  当Thread-1 进行轻量级加锁时，Thread-0已经对该对象加了轻量级锁![在这里插入图片描述][cf4aa4e66e5c43fdae7346a0ac65ded8.png]
 *  这时Thread-1加轻量级锁失败，进入锁膨胀流程
    
     *  Object对象申请Monitor锁，让Object指向重量级锁地址
     *  然后自己进入Monitor的EntryList BLOCKED

![在这里插入图片描述][227049a18c8b40ceb06312810a20018d.png]

![194256c98346469ead1551ff3c288658.png][]

*  当Thread-0退出同步块解锁时，使用cas将Mark Word的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照Monitor地址找到Monitor对象，设置Owner为null,唤醒EntryList中BLOCKED线程

### 自旋优化 ###

*  重量级锁竞争的时候，可以使用自旋来进行优化，如果当前线程自旋成功（这时候持锁线程已经退出了同步块，释放了锁），这是线程就可以避免阻塞。

![在这里插入图片描述][4667185c81fb49f4887c84a335068d8f.png]

![在这里插入图片描述][f3e0cf339b9d410ebc93e8b6e7c56968.png]

*  在java6之后自旋锁是适应的，比如对象刚刚的一次自旋操作成功过， 那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就会自旋设置不自旋，总之，比较智能
 *  自旋会占用CPU时间，单核CPU自旋就是浪费，多核CPU自旋才能发挥优势
 *  Java7之后不能控制是否开启自旋功能

## 3.3 偏向锁 ##

轻量级锁在没有竞争时（自己一个线程），每次重入仍然需要执行CAS操作

Java6中引入了偏向锁做进一步优化：只有第一次使用CAS将线程ID设置到对象的Mark Word头，之后发现这个线程ID是自己的就表示没有竞争，这个对象就归该线程所有

static final Object obj = new Object();
    public static void m1(){
        
    	synchronized(obj){
        
    	//同步块A
    		m2();
    	}
    }
    public static void m2(){
        
    	synchronized(obj){
        
    		m3();
    		//同步块B
    	}
    }
    public static void m3(){
        
    	synchronized(obj){
        
    		m2();
    		//同步块C
    	}
    }

![0fe63f6af2594242b67856f2e641544b.png][]

### 1）偏向状态 ###

![在这里插入图片描述][a5728da44c23459d87d84ed6c00ea1de.png]  
![在这里插入图片描述][5e62a4bcc0ff44619ab85ec82d4a080f.png]

### 2）不可偏向 ###

测试禁用  
在运行代码时添加VM参数：-xx: -UseBiasedLocking 禁用偏向锁

### 3）撤销偏向锁 ###

![在这里插入图片描述][eeec26fc5675440aa21d94223fcb6e82.png]  
![在这里插入图片描述][7eeab1894e754d8cba2a8e4fe8bf30b3.png]

### 4）批量重偏向 ###

![在这里插入图片描述][802e2b9c909c4a0184d7cfc98b0472dc.png]

### 5）批量撤销 ###

![在这里插入图片描述][0243abd2a1674629a793c271de9576bc.png]

[cecef3095edc4a7e93b66955fafaaa22.png]: https://img-blog.csdnimg.cn/cecef3095edc4a7e93b66955fafaaa22.png
[41c98d423253486fb11663ddc06b08c6.png]: https://img-blog.csdnimg.cn/41c98d423253486fb11663ddc06b08c6.png
[6a3a6a0a10064aea93369387a664a54d.png]: https://img-blog.csdnimg.cn/6a3a6a0a10064aea93369387a664a54d.png
[d1ee03d651994ff7b5261fd67c0a29f9.png]: https://img-blog.csdnimg.cn/d1ee03d651994ff7b5261fd67c0a29f9.png
[ba5894aed0d7483fbbe50955214d25e9.png]: https://img-blog.csdnimg.cn/ba5894aed0d7483fbbe50955214d25e9.png
[6838d38004444239acde4e04b9b67337.png]: https://img-blog.csdnimg.cn/6838d38004444239acde4e04b9b67337.png
[dfd2277c39b346869d3fb4862699c955.png]: https://img-blog.csdnimg.cn/dfd2277c39b346869d3fb4862699c955.png
[cf4aa4e66e5c43fdae7346a0ac65ded8.png]: https://img-blog.csdnimg.cn/cf4aa4e66e5c43fdae7346a0ac65ded8.png
[227049a18c8b40ceb06312810a20018d.png]: https://img-blog.csdnimg.cn/227049a18c8b40ceb06312810a20018d.png
[194256c98346469ead1551ff3c288658.png]: https://img-blog.csdnimg.cn/194256c98346469ead1551ff3c288658.png
[4667185c81fb49f4887c84a335068d8f.png]: https://img-blog.csdnimg.cn/4667185c81fb49f4887c84a335068d8f.png
[f3e0cf339b9d410ebc93e8b6e7c56968.png]: https://img-blog.csdnimg.cn/f3e0cf339b9d410ebc93e8b6e7c56968.png
[0fe63f6af2594242b67856f2e641544b.png]: https://img-blog.csdnimg.cn/0fe63f6af2594242b67856f2e641544b.png
[a5728da44c23459d87d84ed6c00ea1de.png]: https://img-blog.csdnimg.cn/a5728da44c23459d87d84ed6c00ea1de.png
[5e62a4bcc0ff44619ab85ec82d4a080f.png]: https://img-blog.csdnimg.cn/5e62a4bcc0ff44619ab85ec82d4a080f.png
[eeec26fc5675440aa21d94223fcb6e82.png]: https://img-blog.csdnimg.cn/eeec26fc5675440aa21d94223fcb6e82.png
[7eeab1894e754d8cba2a8e4fe8bf30b3.png]: https://img-blog.csdnimg.cn/7eeab1894e754d8cba2a8e4fe8bf30b3.png
[802e2b9c909c4a0184d7cfc98b0472dc.png]: https://img-blog.csdnimg.cn/802e2b9c909c4a0184d7cfc98b0472dc.png
[0243abd2a1674629a793c271de9576bc.png]: https://img-blog.csdnimg.cn/0243abd2a1674629a793c271de9576bc.png