线程安全

线程安全

线程漏洞最典型的例子就是网上售票。

new Thread(saleThread,"线程一");
new Thread(saleThread,"线程二");
new Thread(saleThread,"线程三");
new Thread(saleThread,"线程四");

上述会发生一张票被多次售出的情况。
归纳 当多线程共享一个共同资源时，会出现如上问题。
原因 线程随机性原理，即线程会被cpu随机切换。
解决方法

1. 设置变量
   if(bool) 可访问
   if(!bool)不可访问

2. synchronized
   同步代码块

synchronized(lock){
  操作共享资源代码块
  }

同步方法

synchronized 返回值类型 方法名([参数1,...]){
  //balalala
}

public synchronized void set(String name) {

        if (isConsume) {
            count++;
            this.name = name + count;
            System.out.println(Thread.currentThread().getName() + "生产了"+ this.name);
            isConsume = false;
        }
        //
        notify();
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void get() {
        if (!isConsume) {System.out.println(Thread.currentThread().getName() + "消费了" + name);
            isConsume = true;
        }
        notify();
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}

3.lock替换synchronized
java.util.concurrent.locks.Lock

    lock = new ReentrantLock();
    condition_producer = lock.newCondition();
    condition_consumer = lock.newCondition();

synchronized -> lock.lock();

public void set(String name) {
    lock.lock();
    try {
        //生产了
        condition_consumer.signal();
        // 消费了才出来生产
        condition_producer.await();        
    } finally {
        lock.unlock();// 必须执行!!!!!防止死锁!!
    }
}

public void get() {
    lock.lock();
    try {
         "消费了"
        condition_producer.notify();
        condition_consumer.wait();
    } finally {
        lock.unlock();
    }
}

Lock

• void lock()
• -

获取锁。

• void lockInterruptibly()

如果当前线程未被中断，则获取锁。

• Condition newCondition()

返回绑定到此 Lock 实例的新 Condition 实例。

• boolean tryLock()

仅在调用时锁为空闲状态才获取该锁。

• boolean tryLock(long time, TimeUnit unit)

如果锁在给定的等待时间内空闲，并且当前线程未被中断，则获取锁。

• void unlock()

释放锁。

wait(), notify(), notify All()

• wait() 是当前cpu放弃同步锁并进入等待（释放cpu,释放锁），直到其他线程进入同步锁，并调用notify()或notify All()唤醒该线程为止
• notify() 唤醒同步锁上等待的第一个调用wait()的线程
• notify All() 唤醒同步锁上调用wait()的所有线程
  注意：
  上述三种方法必须在同步代码块或同步方法里
  必须由锁对象调用
  IllegalMonitorStateException 非法的监控异常

sleep()和wait()的区别

描述	sleep	wait
属于哪个类	Thread	Object
是否让出cpu	是	是
是否释放锁	否	是
时间	可以	可以
使用要求	无	必须在同步里面,锁对象调用
中断InterruptedException	线程终止	线程终止

线程状态

• BLOCKED

受阻塞并且正在等待监视器锁的某一线程的线程状态。

    public void run() {

        synchronized (this) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        ThreadBlocked ttw = new ThreadBlocked();
        Thread thread1 = new Thread(ttw);
        Thread thread2 = new Thread(ttw);
        thread1.start();
        thread2.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread2.getState());
    }

• NEW

至今尚未启动的线程的状态。

    public void run() {}

    public static void main(String[] args) {
        Thread thread = new Thread();
        /**休眠一下 给时间切换到线程thread 否则输出主线程main的状态**/
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread.getState());
    }

• RUNNABLE

可运行线程的线程状态。

    public void run() {}

    public static void main(String[] args) {
        Thread thread = new Thread();
        thread.start();
        System.out.println(thread.getState());
    }

• TERMINATED

已终止线程的线程状态。

    public void run() {}

    public static void main(String[] args) {
        ThreadTerminated ttw = new ThreadTerminated();
        Thread thread = new Thread(ttw);
        thread.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread.getState());
    }

• TIMED_WAITING

具有指定等待时间的某一等待线程的线程状态。

public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ThreadTimeWaiting ttw = new ThreadTimeWaiting();
        Thread thread = new Thread(ttw);
        thread.start();
        /**
         * 休眠一下 切换到线程thread 否则输出主线程main的状态
         */
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread.getState());
    }

• WAITING

某一等待线程的线程状态。

public void run() {
        synchronized (this) {
            try {
                wait();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }

        }
    }

    public static void main(String[] args) {
        ThreadWaiting ttw = new ThreadWaiting();
        Thread thread = new Thread(ttw);
        thread.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(thread.getState());
    }

线程池

管理线程，存放等待线程
Thread创建的线程不在线程池里面。
通过线程池创建的线程默认为后台线程，优先级默认为Normal.
执行方法execute,结束方法shutdown

---

优点：线程的创建与销毁都要耗费大量的时间，创建多线程也会占据大量的空间。线程池的出现不仅利于管理，还解决了上述问题。