黑马程序员——java 多线程

------- android培训、java培训、期待与您交流！ ----------

多线程

1、进程和线程

进程：运行中的应用程序称为进程，拥有系统资源（CPU、内存）。

线程：进程中的一个独立控制单元，一个进程可以有多个线程。本身不拥有资源（共享所在进程的资源）。

主线程：Java 虚拟机启动的时候会有一个进程java.exe，该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中。该线程即为主线程。

多进程：在同一个操作系统运行多个任务。

多线程：在同一个应用程序中有多个功能流同时运行。

多线程的意义：

（1）可以实现程序的并发执行效果，提高系统性能。

（2）在多线程中可以通过优先级管理，使重要的程序优先执行，提高CPU的处理效率。

（3）在多CPU系统中，可以把不同的线程在不同的CPU中执行，真正做到处理多任务。

2、创建线程方式一：继承Thread类

步骤：

（1）定义类继承Thread类。

（2）子类复写Thread中的run()方法，将线程运行的代码放到run()方法中。

（3）创建线程：建立子类对象的同时线程也就被创建了。

（4）通过调用start()开启线程。

示例：

class Demo extends Thread{public void run(){for(int x=0; x<60; x++)System.out.println("demo run---"+x);}}class ThreadDemo {public static void main(String[] args) {Demo d = new Demo();//创建好一个线程。d.start();//开启线程并执行该线程的run方法。//d.run();//仅仅是对象调用方法。创建了线程，但线程没有启动。for(int x=0; x<60; x++)System.out.println("主线程---"+x);}}

3、线程的四种状态

被创建：线程对象已经产生，但是尚未被启动。
运行：线程正在运行中。
冻结：由于某种原因（sleep或wait）导致真在运行的线程让出CPU并暂停自己的执行。
消亡：这个状态下表示该线程的run方法已经已经执行完毕了，已经相当于死亡了。

4、创建线程的方式二：实现Runable接口

步骤：

（1）定义类实现Runnable接口。

（2）复写Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。

（3）通过Thread类建立线程对象。

（4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

思考：为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，就必须明确该run方法所属对象。

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

示例：

class Ticket implements Runnable{private  int tick = 100;public void run(){while(true){if(tick>0){System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);}}}}class  TicketDemo{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();}}

重点：实现方式的好处是：避免了单继承的局限性（在定义线程时，建立使用实现方式）。

两种方式区别：

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

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

5、线程安全问题

导致安全问题出现的原因：

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

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。对此Java提供了一种专业解决方式，即同步代码块。

同步代码块格式：

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

对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

示例：

class Ticket implements Runnable{private  int tick = 1000;Object obj = new Object();public void run(){while(true){synchronized(obj)//同步代码块，相当于加锁{if(tick>0){try{Thread.sleep(10);}catch(Exception e){}//特意使程序出现不安全状况System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);}}}}}class  TicketDemo2{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();}}

同步的前提：

（1）必须要有两个或者两个以上的线程。

（2）必须是多个线程使用同一个锁。

同步的好处：解决了多线程的安全问题。

同步的弊端：多个线程需要判断锁，较为消耗资源。

6、同步函数

格式：

在函数上加上synchronized修饰符即可。

示例：

class Ticket implements Runnable{private  int tick = 100;public void run(){while(true){show();//调用同步函数}}public synchronized void show()//同步函数{if(tick>0){try{Thread.sleep(10);}catch(Exception e){}System.out.println(Thread.currentThread().getName()+"...sale : "+ tick--);}}}class  TicketDemo{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);t1.start();//开启线程t2.start();t3.start();}}

思考：同步函数用的是哪个锁呢？

分析：函数需要被对象调用，那么函数都有一个所属对象引用，就是this。
结论：同步函数使用的锁是this。

如果同步函数被静态修饰后，使用的锁是什么呢？

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

7、线程间通信

示例：

生产消费商品：多个线程生产商品，多个线程消费商品。

要求：生产一个商品，就消耗一个商品。

class Resource{private String name;private int count = 1;private boolean flag = false;public synchronized void set(String name){while(flag)//让被唤醒的线程再一次判断flag。try{this.wait();}catch(Exception e){}this.name = name+"--"+count++;System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);flag = true;this.notifyAll();//唤醒对方线程，因为只用notify时，容易出现只唤醒本方线程，//对方线程未唤醒而导致程序中所有线程都等待。} public synchronized void out(){while(!flag)try{wait();}catch(Exception e){}System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);flag = false;this.notifyAll();}}class Producer implements Runnable//生产商品{private Resource res;Producer(Resource res){this.res = res;}public void run(){while(true){res.set("+商品+");}}}class Consumer implements Runnable//消费商品{private Resource res;Consumer(Resource res){this.res = res;}public void run(){while(true){res.out();}}}class ProducerConsumerDemo {public static void main(String[] args) {Resource r = new Resource();Producer pro = new Producer(r);Consumer con = new Consumer(r);Thread t1 = new Thread(pro);//生产线程Thread t2 = new Thread(pro);Thread t3 = new Thread(con);//消费线程Thread t4 = new Thread(con);t1.start();//启动线程t2.start();t3.start();t4.start();}}

思考1：wait()，notify()，notifyAll()用来操作线程，为什么不定义在Thread类中而定义在Object类中？

（1）这些方法都使用在同步中，因为要对持有监视器（锁）的线程操作，所以都使用在同步中（只用同步才具有锁）。

（2）这些方法在操作同步中线程时，都必须要标识它们所属同步的锁。

（3）锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中。

思考2：wait()，sleep()有什么区别？

wait()释放CPU资源，释放锁。

sleep()释放CPU资源，不释放锁。