Day11
/*
进程：是一个正在被执行中的程序。
每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立完成控制单元。
线程在控制着进程的执行。
一个进程中至少有一个线程。
创建线程的第一种方式， 继承Thread类
步骤：
1.定义类继承Thread类
2.复写Thread类中的run方法,(目的是将自定义代码存储在run方法中，让线程运行。)
3.实例化定义的类，调用start方法，
start方法有两个作用，1）启动线程 2）调用run方法
为什么覆盖run方法呢
Thread类用于描述线程。
该类定义了一个功能，用于存储线程要运行而定代码，该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程运行的代码。
*/
class D11Demo extends Thread { public void run() { for (int i=0;i<100;i++ ) { System.out.println("---demo run---"+i); } } } class D11TheradDemo { public static void main(String[] args) { Demo d = new Demo(); d.start();//开启线程并执行该线程的run方法。 d.run();//仅仅是对象的函数调用，而线程创建了，并没有运行。 // for (int i=0;i<100;i++ ) { System.out.println("---mian run---"+i); } } } /* 练习： 创建两个线程和主线程交替运行 通过 this.getName()或Thread.currentThread() 方法可以获取线程名称 */ class D11Test1 extends Thread { public void run() { for (int i=0;i<30;i++ ) { System.out.println(getName()+"---run---"+i); } } } class D11Test2 extends Thread { public void run() { for (int i=0;i<30;i++ ) { System.out.println(getName()+"---run---"+i); } } } class D11Test3 extends Thread { public void run() { for (int i=0;i<30;i++ ) { System.out.println(getName()+"---run---"+i); } } } class D11TheradTestDemo { public static void main(String[] args) { D11Test1 t1 = new D11Test1(); t1.start(); D11Test2 t2 = new D11Test2(); t2.start(); D11Test3 t3 = new D11Test3(); t3.start(); for (int i=0;i<30;i++ ) { System.out.println("---mian run---"+i); } } } /* 练习2 需求：简单的买票程序。 多个窗口同时买票。 创建线程的第二种方法，实现 Runnable 接口 步骤 1.定义类实现Runnable接口 2.覆盖Runnable接口中的run方法。 将线程要运行的代码存放在run方法中） 3.通过Thread类建立线程对象。 4.将Runnable接口的子类对象作为实际参数给Thread类的构造函数。 自定义的run方法所属的对象时Runnable接口的子类对象，所以要让线程调用指定对象的run方法，就必须明确该run方法的对象。 5.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。 两种方式的区别: Runnable方式: 1.避免的单继承的局限性，在定义线程是建议使用该方式。 2.线程代码存在Runnable子类的run方法中 继承Thread方式： 1.有局限性，因为Java的单继承特性如果继承可Thread类限制了继承其他类。 2.线程带代码存放在Thread子类的run方法中。 */ class D11Ticket implements Runnable//Thread { private int tick = 100; public void run() { while(true) { if(tick >0) { /* try { Thread.sleep(10); } catch (Exception e) { } */ /* 通过上面代码 Thread.sleep(10); 分析发现 打印出 0 -1 -2 等错票 多线程的运行出现的安全问题。 问题的原因： 当多条语句在操作同一个线程共享数据时， 一个线程对多条语句执行了一部分，还没有执行完毕时， 另一个线程参与进来执行，导致共享数据的错误。 解决方法: 对于多条操作的共享数据的语句，只能让一个线程都执行完毕。 在一个线程执行过程中，其他线程不可以参与执行。 Java对于多线程的安全问题提供了一个同步代码块用于解决这种问题。 格式如下： synchronized(对象) { } */ System.out.println(Thread.currentThread().getName()+" Sale :"+ tick --); } } } } class D11TicketDemo { public static void main(String[] args) { D11Ticket t1 = new D11Ticket(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); } } /* Java对于多线程的安全问题提供了一个同步代码块用于解决这种问题。 格式如下： synchronized(对象) { } 对象如同锁，持有锁的线程可以再同步中执行， 没有持有锁的线程即使获取到CPU的执行权，也进不去，因为没有锁。 同步的前提： 1.必须要有两个或者两个以上的线程。 2.必须是多个线程使用同一个锁。 同步的利弊: 利：保证只用一个线程在执行，解决了多线程中多条语句在操作同一个线程共享数据时的安全问题。 弊：多个线程都需要判断锁，较为消耗资源。 */ class D11Ticket2 implements Runnable//Thread { private int tick = 100; 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 D11TicketDemo2 { public static void main(String[] args) { D11Ticket2 t1 = new D11Ticket2(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); } } /* 练习3 需求： 银行有一个金库 有两个存户分别存300斤黄金，每次存100斤，存3次。 目的： 该程序是否有安全问题，如果有，如何解决？ 如何找问题： 1.明确哪些代码是多线程执行代码。 2.明确哪些是共享数据。 3.明确多线程运行代码中哪些语句是操作共享数据的。 */ class D11Bank { private int sum; //同步函数也可以解决这种问题。 public synchronized void add(int n) { sum +=n; // try{Thread.sleep(1000);}catch (Exception e){} System.out.println("sum="+ sum); } } class D11Cus implements Runnable { private D11Bank b = new D11Bank(); public void run() { for(int i =0; i<3 ;i++ ) { b.add(100); } } } class D11BankDemo { public static void main(String[] args) { D11Cus c = new D11Cus(); // Thread t1 = new Thread(c); Thread t2 = new Thread(c); // t1.start(); t2.start(); } } /* 同步函数用的是哪一个锁呢？ 函数需要被对象调用，那么函数都有一个所属对象引用，就是this。 所以同步函数使用的锁是this 下面通过该程序进行验证： 使用线程来卖票 一个线程在同步代码中，一个线程在同步函数中。 都在执行卖票动作 */ class D11Ticket3 implements Runnable//Thread { private int tick = 100; Object obj = new Object(); boolean flag = true; public void run() { if(flag) { while(true) { synchronized(this) { if(tick >0) { try{Thread.sleep(10);}catch (Exception e){} // System.out.println(Thread.currentThread().getName()+" code Sale :"+ tick --); } } } } else { while(true) { show(); } } } public synchronized void show() { if(tick >0) { try{Thread.sleep(10);}catch (Exception e){} // System.out.println(Thread.currentThread().getName()+" function Sale :"+ tick --); } } } class D11TicketDemo3 { public static void main(String[] args) { D11Ticket3 t = new D11Ticket3(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); // t1.start(); try{Thread.sleep(10);}catch (Exception e){} t.flag =false; t2.start(); } } /* 如果同步函数被static修饰后，使用的锁是什么呢？ 静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。 类名.class 该对象的类型是Class 所以 静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class */ class D11Ticket4 implements Runnable//Thread { private static int tick = 100; Object obj = new Object(); boolean flag = true; public void run() { if(flag) { while(true) { //synchronized(obj) synchronized(D11Ticket4.class) { if(tick >0) { try{Thread.sleep(20);}catch (Exception e){} // System.out.println(Thread.currentThread().getName()+" code Sale :"+ tick --); } } } } else { while(true) { show(); } } } public static synchronized void show() { if(tick >0) { try{Thread.sleep(10);}catch (Exception e){} // System.out.println(Thread.currentThread().getName()+" function Sale :"+ tick --); } } } class D11TicketDemo4 { public static void main(String[] args) { D11Ticket4 t = new D11Ticket4(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); // t1.start(); try{Thread.sleep(10);}catch (Exception e){} t.flag =false; t2.start(); } } /* 重提 单例设计模式 */ /* //饿汉式 class Single { private static final Single s =new Single(); private Single(); public static Single getInstance() { return s; } } */ //懒汉式 class D11Single { private static D11Single s =null; private D11Single(){} public static D11Single getInstance() { //双重判断 if(s == null) { synchronized(D11Single.class) { if(s == null) { s = new D11Single(); } } } return s; } } /* 死锁 同步中嵌套同步 */ class D11Ticket5 implements Runnable//Thread { private static int tick = 100; Object obj = new Object(); boolean flag = true; public void run() { if(flag) { while(true) { synchronized(D11Ticket4.class) { show(); } } } else { while(true) { show(); } } } public static synchronized void show() { synchronized(D11Ticket4.class) { if(tick >0) { try{Thread.sleep(20);}catch (Exception e){} // System.out.println(Thread.currentThread().getName()+" code Sale :"+ tick --); } } } } class D11TicketDemo5 { public static void main(String[] args) { D11Ticket5 t = new D11Ticket5(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); // t1.start(); try{Thread.sleep(10);}catch (Exception e){} t.flag =false; t2.start(); } } class D11TestLock implements Runnable { private boolean flag; D11TestLock(boolean flag) { this.flag = flag; } public void run() { if(flag) { synchronized(D11MyLock.locka) { System.out.println("if locka"); synchronized(D11MyLock.lockb) { System.out.println("if lockb"); } } } else { System.out.println("else lockb"); synchronized(D11MyLock.lockb) { synchronized(D11MyLock.locka) { System.out.println("else locka"); } } } } } class D11MyLock { static Object locka = new Object(); static Object lockb = new Object(); } class D11DeadLockTest { public static void main(String[] args) { Thread t1 = new Thread(new D11TestLock(true)); Thread t2 = new Thread(new D11TestLock(false)); // t1.start(); t2.start(); } } Day12 /* 线程间通讯 其实就是多个线程在操作同一个资源 但是操作的动作不同 wait();线程存储在线程池中 notify();唤醒线程池中的线程，通常唤醒顶部的线程。 notifyAll();;唤醒线程池中所有的线程 这些作线程的方法要使用在同步中，因为要对持有监视器(锁)的线程操作。 所以要使用在同步中，因为只有同步才具有锁。 为什么这些操作线程的方法要定义在Object类中呢？ 因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁。 只有同一个锁上的被wait()的线程，才可以被同一个锁上的notify()唤醒线程，不可以对不同锁中的线程进行唤醒。 (也就是说，等待和唤醒线程的必须是同一个锁。) 因为锁可以使任意对象，所以可以被任意对象调用的方法只能有Object，所以定义在Object类中。 */ import java.util.concurrent.locks.*; class D12Res { String name; String sex; boolean flag = false; } class D12Input implements Runnable { private D12Res r; D12Input(D12Res r) { this.r = r ; } public void run() { int i=0; while(true) { synchronized(r) { if(r.flag) try{r.wait();}catch (Exception e){} if(i%2==0) { r.name ="tom"; r.sex = "man"; } else { r.name ="赫尔"; r.sex = "女"; } i++; r.flag =true; //唤醒OutPut r.notify(); } } } } class D12Output implements Runnable { private D12Res r; D12Output(D12Res r) { this.r = r ; } public void run() { while(true) { synchronized(r) { if(!r.flag) try{r.wait();}catch (Exception e){} System.out.println(r.name+" "+r.sex); // r.flag =false; r.notify(); } } } } class D12InPutAndOutPutDemom { public static void main(String[] args) { D12Res r = new D12Res(); D12Input in = new D12Input(r); D12Output out = new D12Output(r); Thread t1 = new Thread(in); Thread t2 = new Thread(out); t1.start(); t2.start(); } } /* 改进D12Res */ class D12Res2 { private String name; private String sex; private boolean flag = false; public synchronized void set(String name, String sex ) { if(flag) try{this.wait();}catch (Exception e){} this.name = name ; this.sex = sex; flag = true; this.notify(); } public synchronized void out() { if(!flag) try{this.wait();}catch (Exception e){} System.out.println(this.name+" "+this.sex); flag = false; this.notify(); } } class D12Input2 implements Runnable { private D12Res2 r; D12Input2(D12Res2 r) { this.r = r ; } public void run() { int i=0; while(true) { if(i%2==0) r.set("tom" ,"man" 