生产者和消费者的实现

class MainActivity : AppCompatActivity() {
    private val TAG = ""
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
		//数据中心
        val market = DataMarket()

        // runnable方式
        val pro = Producer(market)
        val con = Consumer(market)
        //开始
        pro.start()
        con.start()
        // 停止
        Handler(Looper.myLooper()!!).postDelayed({
            pro.stop()
            con.stop()
        }, 1000)
        
        // thread方式
        // val proThread = ProThread(market)
        // val conThread = ConThread(market)
        // proThread.start()
        // conThread.start()
    }

    /**
     * 生产Runnable
     */
    class Producer(private val market: DataMarket) : Runnable {

        //线程运行标志
        private val running = AtomicBoolean(false)
        private lateinit var worker: Thread
        //模拟数据
        private var d = 0
        fun start() {
            worker = Thread(this, "生产者")
            worker.start()
        }
        fun stop() {
            running.set(false)
        }
        override fun run() {
            running.set(true)
            //模拟生产
            while (running.get()) {
                market.make(++d)
                //随机休眠一段时间
                Thread.sleep(Random.nextLong(50))
            }
        }
    }

    /**
     * 消费Runnable
     */
    class Consumer(private val market: DataMarket) : Runnable {
        //线程运行标志
        private val running = AtomicBoolean(false)
        private lateinit var worker: Thread
        fun start() {
            worker = Thread(this, "消费者")
            worker.start()
        }
        fun stop() {
            running.set(false)
        }
        override fun run() {
            running.set(true)
            //模拟消费
            while (running.get()) {
                market.sale()
                //随机休眠一段时间
                Thread.sleep(Random.nextLong(50))
            }
        }
    }
    
    /**
     * 可将开启/停止方法封装成Base
     */
    open class BaseRunnable(private val threadName: String) : Runnable {
        //线程运行标志
        val running = AtomicBoolean(false)
        private lateinit var worker: Thread
        fun start() {
            worker = Thread(this, threadName)
            worker.start()
        }
        fun stop() {
            running.set(false)
        }
        override fun run() {
        }
    }

    /**
     * Base类的使用
     */
    class MyRunnable(name: String = Thread.currentThread().name) : BaseRunnable(name) {
        override fun run() {
            running.set(true)
            while (running.get()) {
                //TODO
            }
        }
    }


    //region ========================= Thread方式 ================================
    /**
     * 生产线程
     */
    class ProThread(private val market: DataMarket) : Thread() {
        private var d = 0
        override fun run() {
            //模拟生产
            while (true) {
                market.make(++d)
                //随机休眠一段时间
                sleep(Random.nextLong(50))
            }
        }
    }

    /**
     * 消费线程
     */
    class ConThread(private val market: DataMarket) : Thread() {
        override fun run() {
            //模拟消费
            while (true) {
                market.sale()
                //随机休眠一段时间
                sleep(Random.nextLong(50))
            }
        }
    }
    // endregion
}

class DataMarket {

    private val mList: MutableList<Int> = mutableListOf()

    // 重入锁
    private val lock = ReentrantLock()
    // 锁的条件
    private val condition = lock.newCondition()

    private val MAX_CAPACITY = 10

    /**
     * 生产
     * @param data 新增的数据
     */
    fun make(data: Int) {
        //操作队列先加锁
        lock.lock()
        try {
            while (mList.size >= MAX_CAPACITY) {
                Log.d(TAG, "仓库已满")
                //仓库已满，不再接受新的数据
                try {
                    condition.await()
                } catch (e: InterruptedException) {
                    e.printStackTrace()
                }
            }

            //仓库未满，将新增的数据放入仓库中
            mList.add(data)
            Log.d(TAG, "${Thread.currentThread().name} 生产成功: $data")
            //生产成功，唤醒其他线程
            condition.signalAll()
        } finally {
            lock.unlock()
        }
    }

    /**
     * 消费
     */
    fun sale() {
        lock.lock()
        try {
            while (mList.size <= 0) {
                Log.d(TAG, "已全部消费")
                //全部消费之后需要停止消费，去生产
                try {
                    condition.await()
                } catch (e: InterruptedException) {
                    e.printStackTrace()
                }
            }
            //取出队列中的数据，对数据进行处理
            val value = mList.first()
            Log.d(TAG, "${Thread.currentThread().name} 消费成功: $value")
            mList.remove(mList.first())
            //全部消费，需要生产
            condition.signalAll()
        } finally {
            lock.unlock()
        }
    }

}