【7.14/7.15】线程Thread

以你之姓@ 2021-09-30 11:20 295阅读 0赞

1）：进程的就绪（Runnable）和阻塞（Blocked）的区别

当处理机空闲时，处于就绪状态的线程就会得到处理器资源，进入运行，当调用yield()时，处于运行状态的线程转入就绪状态。

当线程陷入阻塞时，即使处理机空闲也不会为该进程分配处理器资源，直到相关的动作完成（sleep时间到、I/O输入完成，获得同步锁，收到通知

、resume()），sleep()、等待I/O输入，等待同步锁、等待通知、suspend()等会让进程进入阻塞状态。

2):Lock和synchronized的区别

Lock是一个接口，需要使用其子类ReentrantLock可以创建对象

Lock需要手动上锁，包括上锁的时间和地点，上锁后需要手动解锁

//Lock 的用法
    public static Lock lock=new ReentrantLock();
    public static Condition condition=lock.newCondition();
    Test.lock.lock();
                try {
                        Test.condition.signal();
                         Test.condition.await();            
                } finally {
                    Test.lock.unlock();
                }

//synchronized的用法
    private Res res;//这个res是需要上锁的资源
    synchronized (res) {
                    res.notify();
                    try {
                        res.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }

3）：信号量（Semaphore）的用法

//创建一个银行账户Account类，在创建并启动100个线程往同一个Account类实例里面添加一块钱
    public static class Account{
        private static Semaphore semaphore = new Semaphore(1);  //创建一个信号量
        private int balance =0;
        public int getBalance(){
            return balance;
        }
        public  void deposit(int amount){
            try {
                semaphore.acquire();
                int newBalance = balance + amount;
                Thread.sleep(4);   
                balance= newBalance;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                semaphore.release();   //返回一个信号量
            }
        }
    }

转载于:https://www.cnblogs.com/yuwenhui/p/7183199.html