428 线程的生命周期
429 理解线程的安全问题
1.线程的同步
1、提出问题： 多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
430 线程安全问题的举例和解决措施
例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式
1.问题：卖票过程中，出现了重票，错票----出现了线程的安全问题
2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
3.如何解决：当一个线程在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变
431 同步代码块处理实现Runnable的线程安全问题
4.在java中，通过同步机制，来解决线程的安全问题
方式一：同步代码块
synchronized(同步监视器){
//需要被同步的代码
}
说明：1.操作共享数据的代码，即为需要被同步的代码---不能包含代码多了，也不能包含代码少了
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
3.同步监视器：俗称：锁。任何一个类的对象，都可以充当锁
要求：多个线程必须要共用同一把锁
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
方式二：同步方法
5.同步的方式，解决了线程的安全问题----好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低--局限性
432 同步代码块处理继承Thread类的线程安全问题
说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器
/**
* 使用同步代码块解决继承Thread类的方式的线程安全问题
*
* 例子：创建三个c窗口卖票，总票数为100张
*/
class Windows extends Thread{
private static int ticket = 100;
private static Object obj = new Object();
@Override
public void run() {
while(true){
//正确的
// synchronized (obj) {
synchronized (Windows.class){ //Class clazz = Windows.class
//错误的，因为此时this表示的是t1,t2,t3三个对象
// synchronized (this) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + ":卖票，票号为: " + ticket);
ticket--;
} else {
break;
}
}
}
}
}
public class WindowsTest2 {
public static void main(String[] args) {
Windows t1 = new Windows();
Windows t2 = new Windows();
Windows t3 = new Windows();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
433 同步方法处理实现Runnable的线程安全问题
方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的
同步监视器：this
434 同步方法处理继承Thread类的线程安全问题
关于同步方法的总结：
1，同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2，非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本身
435 线程安全的单例模式之懒汉式
使用同步机制将单例模式中的懒汉式改写为线程安全的
public class BankTest{
}
class Bank{
private Bank(){}
private static Bank instance=null;
public static Bank getInstance(){
//方式一：效率稍差
synchronized(Bank.class){
if(instance==null){
instance=new Bank();
}
return instance;
}
//方式二：效率更高
if(instance==null){
synchronized(Bank.class){
if(instance==null){
instance=new Bank();
}
}
}
return instance;
}
}436 死锁的问题
1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，
都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
2.说明:
》出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
》我们使用同步时，要避免出现死锁。
public class ThreadTest{
public static void main(String[] args){
StringBuffer.s1=new StringBuffer();
StringBuffer.s2=new StringBuffer();
new Thread(){
public void run(){
synchroized(s1){
s1.append("a");
s2.append("1");
try{
Thread.sleep(millis:100);
}catch(InterruptedExpection e){
e.printStackTrace();
}
synchronized(s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}.start();
new Thread(new Runnable(){
public void run(){
synchroized(s2){
s1.append("c");
s2.append("3");
try{
Thread.sleep(millis:100);
}catch(InterruptedExpection e){
e.printStackTrace();
}
synchronized(s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}437 Lock锁方式解决线程安全问题
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
class Window implements Runnable{
private int ticket=100;
//1.实例化ReentrantLock
private ReentrantLock lock=new ReentrantLock(fair:true);
public void run(){
while(true){
try{
//2.调用锁定方法lock()
lock.lock();
if(ticket>0){
try{
Thread.sleep(millis:100);
}catch(InterruptedExpection e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":售票，票号为："+ticket);
ticket--;
}else{
break;
}
}finally{
//3.调用解锁方法：unlock()
lock.unlock();
}
}
}
}
public class LockTest{
public static void main(String[] args){
Window w=new Window();
Thread t1=new Thread(w);
Thread t2=new Thread(w);
Thread t3=new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}1.面试题：synchronized与lock的异同
同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码之后，自动的释放同步监视器
2.优先使用顺序：
Lock---同步代码块（已经进入了方法体，分配了相应资源）----同步方法（在方法体之外）
面试题：如何解决线程安全问题，有几种方式
438 同步机制的课后练习
银行有一个账户。
* 有两个储户分别向同一个账户存3000元，每次存1000，存3次。
* 每次存完打印账户余额。
*
* 分析：
* 1.是否是多线程问题？是，两个储户线程
* 2.是否有共享数据？有，账户（或账户余额）
* 3.是否有线程安全问题？有
* 4.需要考虑如何解决线程安全问题？同步机制：有三种方式。
class Account{
private double balance;
public Account(double balance){
this.balance=balance;
}
//存钱
public synchroized void deposit(double amt){
if(amt>0){
balance+=amt;
try{
Thread.sleep(mills:1000);
}catch(InterruptedExpection e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":存钱成功，余额为："+balance);
}
}
}
class Customer extends Thread{
private Account acct;
public Customer(Account acct){
this.acct=acct;
}
public void run(){
for(int i=0;i<3;i++){
acct.deposit(amt:1000);
}
}
}
public class AccountTest{
public static void main(String[] args){
Account acct=new Account(balance:0);
Customer c1=new Customer(acct);
Customer c2=new Customer(acct);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}439 线程通信的例题
线程通信的例子：使用两个线程打印1-100。线程1, 线程2 交替打印
class Number implements Runnable{
private int number=1;
public void run(){
while(true){
synchronized(this){
notify();
if(number<=100){
try{
Thread.sleep(millis:10);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+number);
number++;
try{
//使得调用如下wait()方法的线程进入阻塞状态
wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}else{
break;
}
}
}
}
}
public class CommunicationTest{
public static void main(String[] args){
Number number=new Number;
Thread t1=new Thread(number);
Thread t2=new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}涉及到的三个方法：
wait（）：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify（）：一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的那个
notifyAll（）：一旦执行此方法，就会唤醒被wait的一个线程
说明
1.wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中
2.wait（），notify（），notifyAll（）三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现IllegalMonitorStateException异常
3.wait（），notify（），notifyAll（）三个方法是定义在java.lang.Object类中
440 sleep（）和wait（）的异同
面试题：sleep（）和wait（）的异同
1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
2.不同点：
1.两个方法声明的位置不同：Thread类中声明sleep（），Object类中声明wait（）
2.调用的范围和要求不同：sleep（）可以在任何需要的场景下调用，wait（）必须在使用同步代码块或同步方法中
3.关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep（）不释放锁，wait（）释放锁
441 生产者消费者例题
分析：
1.是否是多线程问题？是，生产者线程，消费者线程
2.是否有共享数据？是，店员（或产品）
3.如何解决线程的安全问题？同步机制，有三种方法
4.是否涉及到线程的通信？是
class Clerk{
private int productCount=0;
public synchronized void producePrdouct(){
if(productCount<20){
productCount++;
System.out.println(Thread.currentThread().getName()+"：开始生产第"+productCount);
notify();
}else{
try{
wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
public synchronized void consumeProduct(){
if(productCount>0){
System.out.println(Thread.currentThread().getName()+"：开始消费第"+productCount);
productCount--;
notify();
}else{
try{
wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
class Producer extends Thread{
private Clerk clerk;
public Producer(Clerk clerk){
this.clerk=clerk;
}
public void run(){
System.out.println(getName()+":开始生产产品");
while(true){
try{
Thread.sleep(millis:10);
}catch(InterruptedException e){
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Consumer extends Thread{
private Clerk clerk;
public Consumer(Clerk clerk){
this.clerk=clerk;
}
public void run(){
System.out.println(getName()+":开始消费产品");
while(true){
try{
Thread.sleep(millis:10);
}catch(InterruptedException e){
e.printStackTrace();
}
clerk.consumeProduct();
}
}
public class ProductTest{
public static void main(String[] args){
Clerk clerk=new Clerk();
Produce p1=new Producer(clerk);
p1.setName("生产者1");
Consumer p1=new Consumer(clerk);
c1.setName("消费者1");
p1.start();
c1.start();
}
}442 实现Callable接口
//1.创建一个实现callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call（）中
public Object call() thorws Exception{
int sum=0;
for(int i=1;i<=100;i++){
if(i%2==0){
System.out.println(i);
sum+=i;
}
}
return sum;
}
}
public class ThreadNew{
public static void main(String[] args){
//3.创建Callable接口实现类的对象
NumThread numThread=new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask=new FutureTask(numThread);
//5.将futuretask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start（）
new Thread(futureTask).start();
try{
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数callable实现类重写的call（）的返回值
Object sum=futureTask.get();
System.out.println("总和为："+sum);
}catch(InterruptedException e){
e. printStackTrace();
}catch(ExecutionException e){
e. printStackTrace();
}
}
}
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
1.call（）可以有返回值
2.call（）可以抛出异常，被外面的操作捕获，获取异常的信息
3.Callable是支持泛型的
Future接口
可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
FutrueTask是Futrue接口的唯一的实现类
FutureTask同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值
443 线程池的好处
1、背景：
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
2、思路：
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
3、好处：
提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
…
线程池相关API
JDK 5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
void shutdown()：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
444 使用线程池
class NumberThread implements Runnable{
public void run(){
for(int i=0;i<=100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadPool{
public static void main(String[] args){
//1.提供指定线程数量的线程池
ExecutorService service=Executors.newFixedThreadPool(nThreads:10);
//2.执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
//service.submit();//适合适用于Callable
//关闭连接池
service.shutdown();
}
}