黑马程序员——Java语言多线程

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

一、多线程

1.1 线程

进程：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径或者叫控制单元。

线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。

理解线程：

1. 一个进程中至少有一个线程

2. JVM 启动的时候会有一个进程java.exe

该进程中至少有一个线程在负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程称为主线程；同时还会启动垃圾回收线程。

3. 开启多个线程是为了同时运行多部分代码，每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

多线程的好处：解决了多部分代码同时运行的问题。

多线程的弊端：线程太多，会导致效率的降低。

1.2 创建线程

1.2.1 继承Thread类

创建方式：

1. 定义一个类继承Thread类。

2. 覆盖Thread类中的run方法。

3. 直接创建Thread的子类对象创建线程。

4. 调用start方法开启线程，该方法有两个作用，启动线程，调用run方法。

为什么要覆盖run方法?

Thread 类用于描述线程

该类定义了一个功能用于存储线程要运行的代码，就是run方法，run方法用于存储线程中要运行的代码

class Demo extends Thread {public void run(){System.out.println("demo run");}}class ThreadDemo {public static void main(String[] args){Demo d = new Demo(); //创建好一个线程d.start();//开启线程并执行该线程的run方法//d.run()  仅仅是对象调用方法，主线程在运行它，新创建的进程没有运行}}

P.S.

1、可以通过Thread的getName方法获取线程的名称，名称格式：Thread-编号（从0开始）。

2、Thread在创建的时候，该Thread就已经命名了。

1.2.2 实现Runnable 接口

创建方式：

1.定义类实现Runnable接口

2.覆盖Runnable接口中的run方法，将线程要运行的代码存放在run方法中

3.通过Thread类建立线程对象

4.将Runnable接口的子类对象作为实际参数传递给Tread类的构造函数

5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

class ThreadDemo{public static void main(String[] args) {Thread t1 = new Thread(new Run());t1.start();for(int y=0;y<10;y++){System.out.println(Thread.currentThread().getName()+"  y="+y);}}}class Run implements Runnable{public void run(){for(int x=0;x<10;x++){System.out.println(Thread.currentThread().getName()+"  x="+x);}}}

每次运行打印的顺序都不一样。 

实现方式与继承方式有什么区别

继承Thread：线程代码存放在Thread子类run方法中

实现Runnable：线程代码存放在接口子类的run方法中

实现：避免类单继承的局限性，在定义线程时建议使用实现方式

实现Runnable接口的好处：

1. 将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。

2. 避免了Java单继承的局限性。 所以，创建线程的第二种方式较为常用。

1.3 线程的安全问题

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行到一部分，另一个线程参与进来，导致共享数据错误

解决办法：操作共享数据时，让一个线程执行完，其他线程再开始执行

1.3.1 java解决办法：同步代码块(锁)

synchronized(对象){    需要被同步的代码}

同步的前提

1.必须有两个以上的线程

2.必须是多个线程使用同一个锁

好处：解决了安全问题

弊端：需要判断锁，较为消耗资源

练习：实现一个卖票程序

class Ticket implements Runnable {public  int tic = 100;Object obj = new Object();public void run(){while(true){synchronized(obj){if(tic>0){try{Thread.sleep(10);  //睡眠再去执行程序可能出现问题}catch(Exception e){}System.out.println(Thread.currentThread().getName()+"..sale:"+tic--);}}}}}class ThreadTest1{public static void main(String[] args){Ticket t = new Ticket();Thread t1 = new Thread(t);Thread t2 = new Thread(t);Thread t3 = new Thread(t);Thread t4 = new Thread(t);t1.start();t2.start();t3.start();t4.start();}}

结果分析：

Object对象相当于是一把锁，只有抢到锁的线程，才能进入同步代码块向下执行。 因此，当tic=1时，CPU切换到某个线程后，如上图的Thread-3线程，其他线程将无法通过同步代码块继而进行if判断语句，只有等到Thread-3线程执行完“tic--” 操作（此后tic的值为0），并且跳出同步代码块后，才能抢到锁。 其他线程即使抢到锁，然而，此时tic值已为0，也就无法通过if语句判断，从而无法再执行“ tic--” 的操作了，也就不会出现0、 -1、 -2等情况了。

1.3.2 同步函数：用synchronized修饰操作共享数据的函数

练习：模拟银行存钱代码

class Bank{private int sum;Object obj = new Object();public synchronized void add(int n)//同步函数{//synchronized(obj)//{sum = sum + n;System.out.println("sum="+sum);//}}}class Cun implements Runnable{private Bank b = new Bank();public void run(){for(int x=0; x<3; x++){b.add(100);}}}class ThreadTest2{public static void main(String[] args){Cun c = new Cun();Thread t1 = new Thread(c);Thread t2 = new Thread(c);t1.start();t2.start();}}

同步函数和同步代码块的区别：

1. 同步函数的锁是固定的this。

2. 同步代码块的锁是任意的对象。

建议使用同步代码块。 

1.3.3 静态函数的同步

被静态修饰的同步函数，通过验证，使用的锁不是this，因为静态方法中也不可以定义this

静态的同步函数，使用的锁是该方法所在类的字节码文件对象：类名.class

多线程下的单例模式，饿汉式不存在安全问题，懒汉式的安全问题可以如下解决

class Single{private static Single s = null;private Single(){}public static Single getInstance(){if(s==null){synchronized(Single.class)}if(s==null)s = new Single();}}return s;}}class SingleDemo{public static void main(String[] args){Single s = Single.getInstance();}}

1.3.4 死锁

死锁常见情景之一：同步的嵌套

//定义一个类来实现Runnable，并复写run方法/*死锁：同步中嵌套同步*/class Test implements Runnable{private boolean flag;Test (boolean flag){this.flag = flag;}public void run(){if(flag){synchronized(mylock.obj1){System.out.println("if obj1");synchronized(mylock.obj2){System.out.println("if obj2");}}}else{synchronized(mylock.obj2){System.out.println("else obj2");synchronized(mylock.obj1){System.out.println("else obj1");}}}}}class mylock{static Object obj1 = new Object();static Object obj2 = new Object();}class DeadLockTest{public static void main(String[] args){Thread t1 = new Thread(new Test(true));Thread t2 = new Thread(new Test(false));t1.start();t2.start();}}

程序处于等待状态，形成死锁

1.4 线程间的通讯

多个线程在处理统一资源，但是任务却不同，这时候就需要线程间通信。

等待/唤醒机制涉及的方法：

1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。

2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。

3. notifyAll()：唤醒线程池中的所有线程

注意：

1、这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。

2、必须要明确到底操作的是哪个锁上的线程！

3、wait和sleep区别？

1）wait可以指定时间也可以不指定。sleep必须指定时间。

2）在同步中时，对CPU的执行权和锁的处理不同。

wait：释放执行权，释放锁。

sleep：释放执行权，不释放锁。

1.5 JDK1.5新特性

同步代码块就是对于锁的操作是隐式的。

JDK1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到了该对象中，将隐式动作变成了

显示动作。

Lock接口：出现替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。同时更为灵

活，可以一个锁上加上多组监视器。

lock()：获取锁。

unlock()：释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在finally中。

Condition接口：出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了

封装，变成Condition监视器对象，可以任意锁进行组合。

Condition接口中的await方法对应于Object中的wait方法。

Condition接口中的signal方法对应于Object中的notify方法。

Condition接口中的signalAll方法对应于Object中的notifyAll方法

/*生产者生产商品，供消费者使用有两个或者多个生产者，生产一次就等待消费一次有两个或者多个消费者，等待生产者生产一次就消费掉*/import java.util.concurrent.locks.*;class Resource {private String name;private int count=1;private boolean flag = false;//多态private Lock lock=new ReentrantLock();//创建两Condition对象，分别来控制等待或唤醒本方和对方线程Condition condition_pro=lock.newCondition();Condition condition_con=lock.newCondition();//p1、p2共享此方法public void setProducer(String name)throws InterruptedException{lock.lock();//锁try{while(flag)//重复判断标识，确认是否生产condition_pro.await();//本方等待this.name=name+"......"+count++;//生产System.out.println(Thread.currentThread().getName()+"...生产..."+this.name);//打印生产flag=true;//控制生产\消费标识condition_con.signal();//唤醒对方}finally{lock.unlock();//解锁，这个动作一定执行}}//c1、c2共享此方法public void getConsumer()throws InterruptedException{lock.lock();try{while(!flag)//重复判断标识，确认是否可以消费condition_con.await();System.out.println(Thread.currentThread().getName()+".消费."+this.name);//打印消费flag=false;//控制生产\消费标识condition_pro.signal();}finally{lock.unlock();}}}//生产者线程class Producer implements Runnable {private Resource res;Producer(Resource res){this.res=res;}//复写run方法public void run(){while(true){try{res.setProducer("商品");}catch (InterruptedException e){}}}}//消费者线程class Consumer implements Runnable{private Resource res;Consumer(Resource res){this.res=res;}//复写runpublic void run(){while(true){try{res.getConsumer();}catch (InterruptedException e){}}}}class  ProducerConsumer{public static void main(String[] args) {Resource res=new Resource();new Thread(new Producer(res)).start();//第一个生产线程 p1new Thread(new Consumer(res)).start();//第一个消费线程 c1new Thread(new Producer(res)).start();//第二个生产线程 p2new Thread(new Consumer(res)).start();//第二个消费线程 c2}}

1.6 停止线程

如何停止线程？

只有一种方法，run方法结束。

启动多线程运行，运行代码通常是循环结构只要控制循环，就可以让run方法结束，也就是线程结束。

特殊情况：

当线程处于冻结状态，就不会读取到标记，那么线程就不会结束。

当没有指定的方式让冻结的线程回复到运行状态时，就需要对冻结进行清除，强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束interrupt()。

class StopThread implements Runnable{private boolean Flag = true;public void run(){while(Flag){System.out.println(Thread.currentThread().getName()+"..run");}}public void changeFlag(){Flag = false;}}class StopThreadDemo{public static void main(String[] args){StopThread st = new StopThread();Thread t1 = new Thread(st);Thread t2 = new Thread(st);t1.setDaemon(true);t2.setDaemon(true);t1.start();t2.start();int num = 0;while (true){if(num++ == 60){break;}System.out.println(Thread.currentThread().getName()+"..."+num);}}}

1.7 操作线程的其他方法

class Demo implements Runnable{public void run(){for(int x=0; x<70; x++){System.out.println(Thread.currentThread().toString()+"...."+x);Thread.yield();//暂停当前正在执行的线程对象，并执行其他线程，可以是线程交替运行}}}class JoinDemo{public static void main(String[] args)  throws Exception{Demo d = new Demo();Thread t1 = new Thread(d);Thread t2 = new Thread(d);t1.start();//t1.join(); t1要求加入运算，主线程释放运算权，直到t1结束，  //主线程开始执行下面的代码，t2开始执行t2.start();t2.setPriority(Thread.MAX_PRIORITY);//t1.join(); //join 要求加入运算,主线程释放执行权//此时t1与t2交替运行，直到t1运算结束，主线程开始执行for(int x=0; x<80; x++){System.out.println("main..."+x);}System.out.println("over");}}

1.join：当A线程执行到B线程的,join()方法时，A就会等待，等到B线程都执行完，A才会执行。join可以用来临时加入线程执行。

2、setPriority（）方法用来设置优先级

        MAX_PRIORITY 最高优先级10

        MIN_PRIORITY   最低优先级1

        NORM_PRIORITY 分配给线程的默认优先级

3、yield（）方法可以暂停当前线程，让其他线程执行。