黑马程序员 - 多线程
多线程
进程：一个正在执行中的程序，每一个进行执行，都有一个执行顺序，该顺序就是一个执行路径，或者加一个执行单元
线程：就是进程中的一个独立的执行路径，一个进程中至少有一个线程。
java vm启动的时候会有一个进程java.exe。
该进程中至少一个线程负责执行java程序的执行，
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展：其中更细节说明java vm启动不止一个线程，还有赋值垃圾回收机制的线程。
创建线程的实现步骤：
方法一
1.定义一个类继承Thread类
2.覆写Thread类中的run方法
3.在主函数中直接创建Thread的子类
4.运行start调用线程
方法二
1.定义一个类实现Runnable接口
2.在此类中写入需要多线程运用的代码
3.将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造函数。
4.运行start调用线程
以下代码简单演示创建线程的两种方式
class Demo1 extends Thread { //第一种方式继承Thread类 private String name; Demo1(String name){ this.name = name; } public void run() { //覆写run方法 for (int i=1;i<10 ;i++ ){ //循环9次打印当前线程名字 System.out.println(name+"...."+i+Thread.currentThread().getName()); //Thread.currentThread().getName() 获取 当前 运行中 线程的名字 } } } class Demo2 implements Runnable { //第二种方式，实现Runnable接口 private String name; Demo2(String name){ this.name = name; } public void run(){ //覆写run方法 for (int i=1;i<10 ;i++ ){ //循环9次打印当前线程名字 System.out.println(name+"...."+i+Thread.currentThread().getName()); //Thread.currentThread().getName() 获取 当前 运行中 线程的名字 } } } public class AThreadDemo { public static void main(String[] args) { /* 创建线程的目的是为了开启一条新的执行路径，去运行指定的代码和其他代码实现同时运行。 而运行的 指定代码就是这个执行路径的任物。 jvm创建的主线程的任物都定义在主函数中。 而自定义的新城用于描述线程，线程是需要任物的，所以Thread类也对任物的描述。 这个任务就通过Thread类中的run方法来体现，也就是run方法就是封装自定义线程运行任务的函数。 run方法中定义的就是线程要运行的任物代码。 */ Demo1 d1 = new Demo1("d1"); Demo2 d2 = new Demo2("d2"); Thread t1 = new Thread(d1); Thread t2 = new Thread(d2); t1.start(); //开启多线程，调用run方法 t2.start(); //t1.run(); //t2.run(); //直接调用run方法,没有线程的随机性. } }
运行结果
由运行结果可知，d1线程和d2线程交替运行，两个线程均创建成功，并在主线程中调用正常。
线程安全
线程安全问题产生的原因：
1.多个线程在操作共享的数据。
2.操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算就会导致线程安全问题的产生。
问题解决思路：
将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不能参与运算。
必须当前线程吧这些代码都执行完毕后，其他线程才可以产于运算。
java中用同步代码块或同步函数解决该问题。
同步代码块的格式：
synchronized(对象) //此处对象为任意对象，可直接用Objct
{
需要被同步的代码
}
同步函数就是用synchronized修饰函数
注意：定义同步函数必须注意需要同步的代码是哪些。
同步的前提：同步中必须有多个线程，并使用同一个锁(即使用的同一个对象)
如果同步函数被静态修饰后，使用的锁是什么？
通过验证，发现不是this，因为静态方法不可以定义this
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
类名.class 该类对象的类型是Class。
静态的同步方法，使用的锁是该方法所在类的字节码所在对象。
多线程练习
需求:有20张票,需要在4个窗口卖完
编程注意：必须保证各个线程是共用的一个num数据
以下代码演示同步代码块解决安全问题的方法
步骤:
1：定义一个Thread类，包含了对卖票的代码
2：在定义Thread类时，将票数num定义为静态变量，从而保证不同线程运行时是对相同的100张票进行调用。
3：在主函数中定义4个线程对象，并用start方法开启线程。
//实现代码一:(应用同步代码块) class Ticket1 extends Thread{ private static int num = 20; //将num储存在方法区，由4个线程共用。 Object obj = new Object(); //对象必须定义在run外 public void run(){ while (num>0){ synchronized(obj){ //此处需要被同步的代码存在多条，必须定义同步代码块 if(num>0){ System.out.println(Thread.currentThread().getName()+"..."+num--); } } } } } public class BThreadTicket1{ public static void main(String[] args){ Ticket1 t1 = new Ticket1(); Ticket1 t2 = new Ticket1(); Ticket1 t3 = new Ticket1(); Ticket1 t4 = new Ticket1(); t1.start(); t2.start(); t3.start(); t4.start(); } }
运行结果
由运行结果可以看出，4个线程交替运行，出售这20张票。
第二种实现方式
步骤：
1:定义一个包含票数，及买票功能的对象Ticket2，并对其扩展Runnable接口,在其中覆写run方法。
2:在主函数中创建票对象
3:在主函数中创建4个线程对象，并将票对象作为它们的构造函数参数
4:运行start方法开启线程
class Ticket2 implements Runnable { private int num = 20; public void run() { while (num>0){ synchronized(Ticket2.class){ if(num>0){ try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"..."+num--); } } } } //定义同步函数，函数需要被对象调用，那么函数都有一个所属对象引用，就是this //所以同步函数使用的锁是this } public class BThreadTicket2 { public static void main(String[] args){ //单独建立一个票的对象，4个线程均是对该票对象的调用 Ticket2 t2 = new Ticket2(); Thread th1 = new Thread(t2); Thread th2 = new Thread(t2); Thread th3 = new Thread(t2); Thread th4 = new Thread(t2); th1.start(); th2.start(); th3.start(); th4.start(); } }
运行结果：
由运行结果可以看出，4个线程交替运行，出售这20张票。
多线程应用
需求：
生产者生成15个产品 ，并且每生产一个产品，消费者就消费一个。
此代码用了新的同步方式，定义锁；并通过定义标记，使消费线程和成产线程交替运行。
import java.util.concurrent.locks.*; class Resource{ //定义商品 private String name; //定义成员变量 private int count = 1; private boolean flag = false; //定义标记 //Lock方法 private Lock lock = new ReentrantLock(); //定义锁 private Condition condition_pro = lock.newCondition(); private Condition condition_cou = lock.newCondition(); public void set(String name) throws InterruptedException //定义生产动作 { if (count<15){ lock.lock(); //获取锁 try{ while (flag) //注意此处用while是因为需要循环判断 condition_pro.await(); //使当前线程等待 this.name = name; //生成一个产品 System.out.println(Thread.currentThread().getName()+name+"生产商品"+(count++)+"----"); flag = true; //改变标记，是下次循环时能够让生产者等待 condition_cou.signal(); //唤醒另一个在等待的线程 } finally { lock.unlock(); //释放锁 } } } public void show() throws InterruptedException //定义消费动作 { if (count<15){ lock.lock(); //获取锁 try{ while (!flag) condition_cou.await(); //让当前线程等待 System.out.println(Thread.currentThread().getName()+"----消费商品"+name+(count-1)); flag = false; //消费一个对象，并改变标记 condition_pro.signal(); //唤醒另一个正在等待的线程 } finally { lock.unlock(); //释放锁 } } } } class Producter implements Runnable{ //定义生成者 private Resource r; Producter (Resource r){ //将商品传给生产者 this.r = r; } public void run(){ //覆写run方法 while (true){ try{ r.set("商品"); //调用生产动作，生产商品 } catch (InterruptedException e){ } } } } class Coustomor implements Runnable{ //定义消费者 private Resource r; Coustomor (Resource r){ //将商品传给消费者 this.r = r; } public void run(){ //覆写run方法 while (true){ try{ r.show(); //调用消费动作消费商品 } catch (InterruptedException e){ } } } } public class CThreadRe{ public static void main(String[] args) { Resource r = new Resource(); //定义商品对象 Producter pro = new Producter(r); //将商品传给生产者 Coustomor cou = new Coustomor(r); //将商品传给消费者 Thread t1 = new Thread(pro); //定义两个生产线程 Thread t2 = new Thread(pro); Thread t3 = new Thread(cou); //定义两个消费线程 Thread t4 = new Thread(cou); t1.start(); t2.start(); t3.start(); t4.start(); } }
运行结果
上面代码实际上是运用流多线程通讯的思想。
线程间通讯：
其实就是多个线程在操作同一个资源，但操作动作不同
实现核心：
多线程的等待唤醒机制
步骤：
1：设置flag标记变量
2: 在同步代码块中设置 锁名.wait() 而且锁名.wait()必须被 try{}catch{}(或是锁对象.await())
3: 在同步代码块中设置 锁名.notify().(或是锁对象.singal())
注意:设置wait() notify()时,运用flag变量做控制
