第一章 多线程基础

join()

执行线程等待被调用线程执行完毕，才执行下步操作

yield()

当前线程让出cpu时间片，让其他任务执行

数据被多个线程共享 - 扣减库存问题

死锁

stop()

stop强制线程代码中断，对象放弃锁(导致数据不同步)

suspend和resume

suspend独占 ：当一个线程的同步方法在执行过程中，线程被挂起，则该线程长期独占对象的所有同步方法直到resume()，这很容易引起死锁

线程的优先级

• 继承特性 线程A启动线程B,则B线程的优先级与A是一样的
• 规则性 高优先的线程总是大部分先执行完(但不一定)
• 随机性 未必高优先的就一定先执行

守护线程

Dameon(保姆工作) 如GC 其他用户线程都执行完毕后，守护线程和系统一块退出

第二章 高并发

synchronized 同步

1. 同步锁是对象锁

无法同步代码块还是同步方法，都是对对象上锁。或者说是对同一主内存数据上锁。

2. 锁重入

某一线程访问某对象的同步方法，该线程仍然可以访问该对象的其他同步方法，不需要等待释放对象锁

3. 同步块局部上锁提高效率

synchronized(非this)与非this同步内容异步执行， 不会争抢this锁(同步方法和对this的同步代码块),极大提高运行效率

4. 同步无法被继承

子类override父方法，仍然需要添加synchronized关键字

5.抛出异常,同步锁释放

6.局部变量是线程安全的

7.读写锁

open class DirtyReadObj {
    var username = "A"
    var password = "aaa"
    @Synchronized
    fun setUser(name: String, pwd: String) {
        this.username = name
        Thread.sleep(3000)
        this.password = pwd
        getUser()
    }
    fun getUser() {
        println(Thread.currentThread().name + "：user=$username, $password")
    }
}
class LockReinObj : DirtyReadObj() {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            var lockRein = LockReinObj()
         Thread(Runnable {
                lockRein.setGoodsBuyer(Goods()) //本同步方法执行完毕后，释放锁，其他线程可以再竞争该对象的同步资源
                println("能否释放锁？") //会的。
                lockRein.setUser("nfsq", "123456") //和t2线程竞争
            }, "t1").start()
           Thread(Runnable {
                lockRein.setUser("zgr", "zgr123") 
            }, "t2").start()
        }
    }

    @Synchronized
    @Description("锁重入")
    fun setGoodsBuyer(goods: Goods) {
        println(Thread.currentThread().name + "已获得本对象的锁，在本同步方法调用setUser同步方法，并不需要释放锁才执行")
        setUser(goods.name, goods.price.toString())
    }
}

synchronized 同步方法

非线程安全就是多个线程对同一对象的变量同时并发访问，产生的结果就是脏读，读到不正确的数据。线程安全就是以获得实例变量的值是通过同步处理的，不会出现脏读

同步代码块的优势

==synchronized使用的对象监控器是同一个。也就是说，当一个线程的同步方法被调用时，对象被锁定，该对象所有同步内容的访问被阻塞，其他线程无法访问==

1. 可以提高效率(锁定更细节)
2. 可以为开发者不能修改代码加锁(如jar包类方法)

脏读

读取到无效数据 甚至对无效数据做操作

Volatile

Volatile的任用: 保持内存可见性