JavaSE之线程Thread

package com.shuhuadream.thread;/** *  * 进程：正在执行的程序称为一个进程 *  * 线程：线程在一个进程中负责了代码的执行，就是进程中一个执行路径 *  * 多线程：线程负责了代码的执行，我们之前没有学过线程，为啥代码可以执行? * 运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有的代码 *  * 一个java应用程序至少有几个线程？ * 至少有两个线程，一个是主方法负责main方法代码的执行，一个是垃圾回收器线程负责垃圾回收 *  * 多线程的好处： * 1.解决了一个进程能同时执行多个任务的问题 * 2.提高了资源的利用率 *  * 多线程的弊端： * 1.增加了cpu的负担 * 2.降低了一个进程中线程的执行概率 * 3.引发了线程安全问题 * 4.出现了死锁想象 *  * 如何创建多线程？ * 方式： * 一、1.自定义一个类继承Thread类 *    2.重写Thread类的run方法 * 重写的目的： * 每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码， * 自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码 *    3.创建Thread的子类对象，并且调用start方法开启线程。 * 一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用， * 直接调用run()方法就相当于调用了一个普通的方法而已，并没有开启新的线程 *  *  *  * 线程的生命周期： *  * */public class Demo01 extends Thread{//把自定义线程的任务代码写在run方法中public void run() {for(int i=0;i<100;i++){System.out.println("自定义线程："+i);}}public static void main(String[] args){Demo01 d = new Demo01();d.start();for(int i=0;i<100;i++){System.out.println("主线程:"+i);}}}

package com.shuhuadream.thread;/* 进程 ：  正在执行的程序称作为一个进程。  进程负责了内存空间的划分。 问题： windows号称是多任务的操作系统,那么windows是同时运行多个应用程序吗？从宏观的角度： windows确实是在同时运行多个应用程序。从微观角度： cpu是做了一个快速切换执行的动作，由于速度态度，所以我感觉不到在切换 而已。线程： 线程在一个进程 中负责了代码的执行，就是进程中一个执行路径，多线程： 在一个进程中有多个线程同时在执行不同的任务。疑问 ：线程负责了代码 的执行，我们之前没有学过线程，为什么代码可以执行呢？运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码。一个java应用程序至少有几个线程？至少有两个线程， 一个是主线程负责main方法代码的执行，一个是垃圾回收器线程,负责了回收垃圾。多线程的好处：1. 解决了一个进程能同时执行多个任务的问题。2. 提高了资源的利用率。多线程 的弊端：1. 增加cpu的负担。2. 降低了一个进程中线程的执行概率。3. 引发了线程安全 问题。4. 出现了死锁现象。如何创建多线程：创建线程的方式：方式一：1. 自定义一个类继承Thread类。2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法中疑问： 重写run方法的目的是什么？     每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码。3. 创建Thread的子类对象，并且调用start方法开启线程。注意：一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，直接调用run方法就相当调用了一个普通的方法而已并没有开启新的线程。 */public class Demo02 extends Thread {@Override  //把自定义线程的任务代码写在run方法中。public void run() {for(int i  = 0 ; i < 100 ; i++){System.out.println("自定义线程："+i);}}public static void main(String[] args) {//创建了自定义的线程对象。Demo02 d = new Demo02();//调用start方法启动线程d.start();for(int i  = 0 ; i < 100 ; i++){System.out.println("main线程："+i);}}}

/* 需求： 模拟3个窗口同时在售50张 票 。 问题1 ：为什么50张票被卖出了150次？出现 的原因： 因为num是非静态的，非静态的成员变量数据是在每个对象中都会维护一份数据的,三个线程对象就会有三份。解决方案：把num票数共享出来给三个线程对象使用。使用static修饰。问题2： 出现了线程安全问题 ?线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。java线程同步机制的方式：方式一：同步代码块同步代码块的格式：synchronized(锁对象){需要被同步的代码...}同步代码块要注意事项：1. 任意的一个对象都可以做为锁对象。2. 在同步代码块中调用了sleep方法并不是释放锁对象的。3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。需求： 一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取一千块，要求不准出现线程安全问题。方式二：同步函数出现线程安全问题的根本原因：1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。2. 有多个语句操作了共享资源。  */class SaleTicket extends Thread{ static int num = 50;//票数  非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。      staticObject o = new Object(); public SaleTicket(String name) {super(name);}@Overridepublic void run() {while(true){//同步代码块synchronized ("锁") {if(num>0){System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}num--;}else{System.out.println("售罄了..");break;}}}}} public class Demo4 {public static void main(String[] args) {//创建三个线程对象，模拟三个窗口SaleTicket thread1 = new SaleTicket("窗口1");SaleTicket thread2 = new SaleTicket("窗口2");SaleTicket thread3 = new SaleTicket("窗口3");//开启线程售票thread1.start();thread2.start();thread3.start();}}

package com.shuhuadream.thread;class Test03 extends Thread{//把自定义线程的任务代码写在run方法中public void run() {for(int i=0;i<100;i++){System.out.println("视频聊天");}}}class Test02 extends Thread{//把自定义线程的任务代码写在run方法中public void run() {for(int i=0;i<100;i++){System.out.println("打字聊天");}}}public class Test01{public static void main(String[] args) {Test02 t2 = new Test02();Test03 t3 = new Test03();t2.start();t3.start();}}

方式二：同步函数  同步函数就是使用synchronized修饰一个函数同步函数要注意的事项：1.如果是一个非静态的同步函数的锁，对象是this对象，如果是静态的同步函数的锁 对象时当前函数所属的类的字节码文件（class对象）2.同步函数的锁对象是固定的，不能由你来指定的推荐使用同步代码块原因：1.同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象时固定的，不能由我们来指定2.同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数的所有代码都被同步了。 */

package com.shuhuadream.thread;/* * java中同步机制解决了线程安全问题，但是同时也引发死锁现象 *  * 死锁现象： *  * 死锁现象出现的根本原因： * 1.存在两个或者两个以上线程 * 2.存在两个或者两个以上共享资源 *  * 死锁现象的解决方案：没有方案，只能尽量避免发生而已 */class DeadLock extends Thread{public DeadLock(String name){super(name);}public void run(){if("张三".equals(Thread.currentThread().getName())){synchronized ("遥控器") {System.out.println("张三拿到了遥控器，准备去拿电池！！");synchronized ("电池") {System.out.println("张三拿到了遥控器和电池，开着空调爽歪歪的吹着。。。");}}}else if("狗娃".equals(Thread.currentThread().getName())){synchronized ("电池") {System.out.println("狗娃拿到了电池，准备去拿遥控器！！");synchronized ("遥控器") {System.out.println("狗娃拿到了遥控器和电池，开着空调爽歪歪的吹着。。。");}}}}}public class Demo02 {public static void main(String[] args) {DeadLock thread1 = new DeadLock("张三");DeadLock thread2 = new DeadLock("狗娃");//开启线程thread1.start();thread2.start();}}

package com.shuhuadream.thread;/* * 自定义线程创建方式： * 方式一：1.自定义一个类继承Thread类 * 2.重写Thread类的run方法，把自定义线程的任务代码写在run方法上 * 3.创建Thread的子对象，并且调用start方法启动一个线程 *  * 注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码， * 如果直接调用run方法，就相当于调用了一个普通的方法而已。 *  * 方式二：1.自定义一个类实现Runnable接口 * 2.实现Runnerable接口的run方法，把自定义线程的任务定义在run方法上 * 3.创建Runnerable实现类的对象. * 4.创建Thread类的对象，并且把Runnerable实现类的对象作为实参传递 * 5.调用Thread对象的start方法开启一个线程 *  * 问题一：请问Runnerable实现类的对象时线程对象吗？ * Runnerable实现类的对象并不是一个线程对象，只不是实现了Runnerable接口的对象而已 * 只有是Thread或者是Thread的子类才是线程对象 *  * 问题二：为什么要把Runnerable实现类的对象作为实参传递给Thread对象呢？作用是什么？ * 作用就是把Runnerable实现类的对象的run方法作为了线程的任务代码去执行了。 *  */public  class Demo03 implements Runnable{public void run(){for(int i=0;i<100;i++){System.out.println(Thread.currentThread().getName()+"："+i);}}public static void main(String[] args) {//创建Runnable实现类的对象Demo03 d = new Demo03();//创建Thread类的对象，把Runnable实现类对象作为实参传递Thread thread = new Thread(d,"狗娃");//Thread类使用Target变量记录了d对象//调用thread对象的方法开启线程thread.start();for(int i=0;i<100;i++){System.out.println(Thread.currentThread().getName()+"："+i);}}}

class SaleTicket implements Runnable{int  num = 50; // 票数@Overridepublic void run() {while(true){synchronized ("锁") {if(num>0){System.out.println(Thread.currentThread().getName()+"售出了第"+ num+"号票");num--;}else{System.out.println("售罄了..");break;}}}}}public class Demo4 {public static void main(String[] args) {//创建了一个Runnable实现类的对象SaleTicket saleTicket = new SaleTicket();//创建三个线程对象模拟三个窗口Thread thread1 = new Thread(saleTicket,"窗口1");Thread thread2 = new Thread(saleTicket,"窗口2");Thread thread3 = new Thread(saleTicket,"窗口3");//开启线程售票thread1.start();thread2.start();thread3.start();}}

package com.shuhuadream.thread;/** * 进程：进程就是正在运行的应用程序，进程负责了内存空间划分 *  * 线程：一个进程中的代码是由线程去执行的，线程也就是进程中一个执行路径 *  * 多线程：一个进程中有多个线程可以同时执行任务 *  * 多线程的好处： * 1.解决了一个进程中可以同时执行多个任务的问题 * 2.提高了资源利用率 *  * 多线程的弊端： * 1.增加了cpu的负担 * 2.降低了一个进程中线程的执行概率 * 3.出现了线程安全问题 * 4.会引发死锁现象 *  * 自定义线程的是实现方式： * 方式一：1.自定义一个类继承Thread类 * 2.重写Thread类的run方法，把自定义线程的任务代码写在run方法上 * 3.创建Thread的子对象，并且调用start方法启动一个线程 *  * 注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码， * 如果直接调用run方法，就相当于调用了一个普通的方法而已。 *  * 出现线程安全问题的根本原因：1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。2. 有多个语句操作了共享资源。线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。java线程同步机制的方式：方式一：同步代码块同步代码块的格式：synchronized(锁对象){需要被同步的代码...}同步代码块要注意事项：1. 任意的一个对象都可以做为锁对象。2. 在同步代码块中调用了sleep方法并不是释放锁对象的。3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。方式二：同步函数  同步函数就是使用synchronized修饰一个函数同步函数要注意的事项：1.如果是一个非静态的同步函数的锁，对象是this对象，如果是静态的同步函数的锁 对象时当前函数所属的类的字节码文件（class对象）2.同步函数的锁对象是固定的，不能由你来指定的推荐使用同步代码块原因：1.同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象时固定的，不能由我们来指定2.同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数的所有代码都被同步了。 */public class Demo01 {}class MoneyThread extends Thread{static int money = 5000;static Object o = new Object();public MoneyThread(String name){super(name);}public synchronized void run(){while(true){synchronized(o){if(money>0){System.out.println(Thread.currentThread().getName()+"取出1000元");money-=1000;}else{System.out.println("余额不足，无法进行取款");break;}}}}}

package com.shuhuadream.thread;/* * java中同步机制解决了线程安全问题，但是同时也引发死锁现象 *  * 死锁现象： *  * 死锁现象出现的根本原因： * 1.存在两个或者两个以上线程 * 2.存在两个或者两个以上共享资源 *  * 死锁现象的解决方案：没有方案，只能尽量避免发生而已 */class DeadLock extends Thread{public DeadLock(String name){super(name);}public void run(){if("张三".equals(Thread.currentThread().getName())){synchronized ("遥控器") {System.out.println("张三拿到了遥控器，准备去拿电池！！");synchronized ("电池") {System.out.println("张三拿到了遥控器和电池，开着空调爽歪歪的吹着。。。");}}}else if("狗娃".equals(Thread.currentThread().getName())){synchronized ("电池") {System.out.println("狗娃拿到了电池，准备去拿遥控器！！");synchronized ("遥控器") {System.out.println("狗娃拿到了遥控器和电池，开着空调爽歪歪的吹着。。。");}}}}}public class Demo02 {public static void main(String[] args) {DeadLock thread1 = new DeadLock("张三");DeadLock thread2 = new DeadLock("狗娃");//开启线程thread1.start();thread2.start();}}

package com.shuhuadream.thread;/* * 自定义线程创建方式： * 方式一：1.自定义一个类继承Thread类 * 2.重写Thread类的run方法，把自定义线程的任务代码写在run方法上 * 3.创建Thread的子对象，并且调用start方法启动一个线程 *  * 注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码， * 如果直接调用run方法，就相当于调用了一个普通的方法而已。 *  * 方式二：1.自定义一个类实现Runnable接口 * 2.实现Runnerable接口的run方法，把自定义线程的任务定义在run方法上 * 3.创建Runnerable实现类的对象. * 4.创建Thread类的对象，并且把Runnerable实现类的对象作为实参传递 * 5.调用Thread对象的start方法开启一个线程 *  * 问题一：请问Runnerable实现类的对象时线程对象吗？ * Runnerable实现类的对象并不是一个线程对象，只不是实现了Runnerable接口的对象而已 * 只有是Thread或者是Thread的子类才是线程对象 *  * 问题二：为什么要把Runnerable实现类的对象作为实参传递给Thread对象呢？作用是什么？ * 作用就是把Runnerable实现类的对象的run方法作为了线程的任务代码去执行了。 *  * 推荐使用：第二种。实现Runable接口的。 * 原因：因为java是单继承，多实现的 *  */public  class Demo03 implements Runnable{public void run(){for(int i=0;i<100;i++){System.out.println(Thread.currentThread().getName()+"："+i);}}public static void main(String[] args) {//创建Runnable实现类的对象Demo03 d = new Demo03();//创建Thread类的对象，把Runnable实现类对象作为实参传递Thread thread = new Thread(d,"狗娃");//Thread类使用Target变量记录了d对象//调用thread对象的方法开启线程thread.start();for(int i=0;i<100;i++){System.out.println(Thread.currentThread().getName()+"："+i);}}}

package com.shuhuadream.thread;/* * 线程通讯：一个线程完成自己的任务时，要通知另外一个线程去完成另外一个任务 * 生产者和消费者 *  * wait(): 等待-----如果线程执行了wait方法，那么线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify方法才能唤醒 * notify(): 唤醒-----唤醒等待的线程

notifyAll():唤醒线程池中所有等待的线程 *  * wait与notify方法要注意的事项： * 1.wait方法与notify方法时属于Object对象的 *  2.wait方法与notify方法必须要在同步代码块或者是同步函数中才能使用 *  3.wait方法与notify方法必须要由锁对象调用 *///产品类class Product{String name;double price;boolean flag = false;//产品是否生产完毕的标识，默认是没有生产完毕}//生产者class Producer extends Thread{Product p;public Producer(Product p){this.p = p;}public Producer(String name){super(name);}public void run(){int i = 0;while(true){synchronized (p) {if(p.flag==false){if(i%2==0){p.name = "苹果";try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}p.price = 6.5;}else{p.name = "香蕉";p.price = 2.0;}System.out.println("生产者生产出了："+p.name+"  价格是："+p.price);p.flag=true;i++;p.notify();//唤醒消费者去消费}else{//已经生产完毕，等待消费者消费try {p.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}}//消费者class Customer extends Thread{Product p;public Customer(Product p){this.p = p;}public void run(){while(true){synchronized (p) {if(p.flag==true){System.out.println("消费者消费了"+p.name+" 价格："+p.price);p.flag = false;p.notify();//唤醒生产者去生产}else{//产品还没生产，等待消费者生产try {p.wait();} catch (InterruptedException e) {e.printStackTrace();}}}}}}public class Demo04 {public static void main(String[] args) {Product p = new Product();//产品//创建生产对象Producer producer = new Producer(p);//创建消费者Customer customer = new Customer(p);//调用start方法开启线程producer.start();customer.start();}}

package com.shuhuadream.thread;/* * 线程的停止： * 1.停止一个线程我们一般都会通过一个变量去控制的。 * 2.如果需要停止一个处于等待状态下的线程，我们需要通过变量配合notify方法或者interrupt()方法来使用 */public class Demo05 extends Thread{boolean flag = true;public Demo05(String name){super(name);}public synchronized void run(){int i = 0;while(flag){try {this.wait();} catch (InterruptedException e) {System.out.println("接收到了异常了。。。");}System.out.println(Thread.currentThread().getName()+":"+i);i++;}}public static void main(String[] args) {Demo05 d = new Demo05("狗娃");d.start();for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName()+":"+i);//当主线程i为80时候if(i==80){d.flag = false;d.interrupt();//把线程的等待状态强制清除，被清除状态的线程会接收到一个InterruptedException//synchronized (d) {//d.notify();//}}}}}

package com.shuhuadream.thread;/* * 守护线程（后台线程）:如果在一个进程中只剩下守护线程，那么守护线程也会死亡 */public class Demo06 extends Thread{public Demo06(String name) {super(name);}@Overridepublic void run() {for(int i=1;i<=100;i++){System.out.println("更新包下载到"+i+"%");if(i==100){System.out.println("更新包下载完毕，准备安装。。。");}try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public static void main(String[] args) {Demo06 d = new Demo06("后台线程");d.setDaemon(true);//setDaemon() 设置线程是否为守护线程，true为守护线程，false为非守护线程System.out.println("是守护线程吗？"+d.isDaemon());//判断线程是否为守护线程d.start();for(int i=1;i<=100;i++){System.out.println(Thread.currentThread().getName()+":"+i);}}}

package com.shuhuadream.thread;/* * join方法： */class Mom extends Thread{@Overridepublic void run() {System.out.println("妈妈洗菜");System.out.println("妈妈切菜");System.out.println("妈妈准备炒菜，发现没酱油。。。");//叫儿子打酱油Son s = new Son();s.start();try {s.join();//加入 一个线程如果执行join语句，那么就有新的线程加入，执行该语句的线程必须要让步给//新加入的线程先完成任务，然后才能继续执行} catch (InterruptedException e) {e.printStackTrace();}System.out.println("妈妈继续炒菜");System.out.println("妈妈全家一起吃饭");}}class Son extends Thread{@Overridepublic void run() {System.out.println("儿子下楼");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("儿子一直往前走。。");System.out.println("儿子打到酱油了");System.out.println("儿子上楼，把酱油给老妈");}}public class Demo07 {public static void main(String[] args) {Mom m = new Mom();m.start();}}