多线程Thread

线程与进程的概述：

要想了解多线程，必须先了解线程，要想了解线程，必须了解进程，因为线程是依赖于进程而存在

什么是进程？
    通过任务管理器我们就看到了进程的存在
    而通过观察，我们发现只有运行的程序才会出现进程。
    进程：就是正在运行的程序
    进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源
    
多进程有什么意义呢？
    单进程的计算机只能进做一件事情，而我们现在的计算机都可以做多件事情
    举例：一遍玩游戏（游戏进程），一边听音乐）（音乐进程）
    也就是说现在的计算机都是支持多线程的，就可以在一个时间段内执行多个任务，并且呢，可以提高CPU的使用率
    
    问题：
        一边玩游戏，一边听音乐是同时进行的呢？
        不是 。因为单CPU在某一时间点上只能做一件事情
        而我们在玩游戏，或者听音乐的时候，CPU在作者程序间的高效谢欢让我们觉得是同时进行的
        
什么是线程呢？
    在同一个进程内又可以执行多个任务，而这每一个任务我们就可以看成是一个线程
    线程：是程序的执行单元，执行路径。是程序使用CPU的最基本单位
    单线程：如果程序只有一条执行路径
    多线程：如果程序有多条执行路径
    
多线程有什么意义呢？
    多线程的存在，不是提高程序的执行速度，其实是为了提高程序的使用率
    程序的执行其实都是在抢CPU的资源，CPU的执行权
    多个进程是在抢这个资源，而其中的某一个进程如果执行的路径比较多，就会有更高的几率抢到CPU的执行权
    我们是不敢保证呢一个线程能够在哪个时刻抢到CPU执行权，所以线程的执行有随机性

/*
 * 进程：
 *         正在运行的程序，是系统进行资源分配合调用的独立单位
 *         每一个进程都有自己的内存空间和系统资源
 * 线程：
 *         是进程中的单个顺序控制流，是一条执行路径
 *         一个进程中如果只有一条执行路径，则被称为单线程程序
 *         一个进程如果有多条执行路径，则被称为多线程程序
 * 举例：
 *         扫雷，迅雷下载
 * 
 * 大家注意两个词汇的区别：并发和并行
 *         前者是逻辑上同事发生，指的是在某一个时间内同事运行多个程序
 *         后者是物理上同事发生，指的是在某一个时间点同事运行多个程序
 * 
 * java程序的运行原理：
 *         由java命令启动JVM，JVM启动就相当于启动了一个进程
 *         接着该进程创建了一个主线程去调main方法
 * 
 * 思考题：
 *         jvm虚拟机的启动是单线程的还是多线程的？
 *             多线程的
 *             原因是垃圾回收线程也要先启动，否则很容易出现内存溢出
 *             现在垃圾回收线程加上前面的主线程，最低启动了两个线程，所以JVM虚拟机是多线程的

第一个多线程：

package com.gz_02;
/*
 * 需求：我们要实现多线程的程序
 * 如何实现呢？
 *         由于线程是依赖进程而存在的，所以我们应该先创建一个进程出来
 *         而进程是由系统创建的，所以我们应该去调用系统功能创建一个系统
 *         java是不能直接调用系统功能的，所以我们没有办法直接实现多线程程序
 *         但是呢？Java可以去调用C/C++写好的程序来实现多线程程序
 *         由C/C++去调用系统功能创建进程，然后由Java去调用这样的东西
 *         然后提供一些类供我么使用，我们就可以实现多线程程序了
 * 那么Java提供的类是什么呢？
 *         Thread
 *         通过查看API，我们发现有两种方式实现多线程程序
 * 
 * 方式1：将类声明为Threa的子类
 * 步骤：
 *         A：自定义MyThread继承Thread类
 *         B：MyThread类重写run()方法
 *             为什么是run()方法呢？
 *         C:创建对象
 *         D:启动线程
 */
public class MyThreadDemo {
    public static void main(String[] args) {
        //创建线程对象
//        MyThread my=new MyThread();
        //启动线程
//        my.run();
//        my.run();
        //调用run()为什么是单线程的呢？
        //因为run()方法直接调用就相当于普通的方法调用，所以你看到的是单线程的效果
        //要想看到多线程的效果，就必须使用另一个方法：start()
        //面试题：
        //run()和start()的区别
        //run()：仅仅是封装被线程执行的代码，直接调用时普通方法
        //start():首先启动了线程，然后再由jvm开启线程，走线程的run()
//        my.start();
        //java.lang.IllegalThreadStateException非法的线程状态异常
        //为什么呢？因为这个相当于是my线程被调用了两次，而不是两个线程启动
//        my.start();
        
        //创建两个线程对象
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        
        my1.start();
        my2.start();
    }
}

package com.gz_02;
/*
 * 该类要重写run()方法，为什么呢？
 * 不是类里的所有代码都需要被线程执行，而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread的run()来包含那些被线程执行的代码
 */
public class MyThread extends Thread{
    @Override
    public void run(){
        //自己写代码
//        System.out.println("好好学习，天天向上");
        //一般来说，被线程执行的方法肯定是比较耗时的，所以我们先使用循环
        for(int i=0;i<300;i++){
            System.out.println(i);
        }
    }
}

设置获取线程名称：

package com.gz_03;
/*
 * 如何获取线程对象名称？
 *    public final String getName()
 *    如何设置线程对象名称？
 *    public final void setName(String str)
 *
 *我想要获取main方法的线程对象的名称，怎么办呢？
 *    public static Thread currentThread() 返回正在执行的线程对象
 */
public class MyThreadDemo {
    public static void main(String[] args) {
//        MyThread my1=new MyThread();
//        MyThread my2=new MyThread();
//        
//        my1.setName("A");
//        my2.setName("B");
        //使用构造给名字
//        MyThread my1=new MyThread("A");
//        MyThread my2=new MyThread("B");
//        my1.start();
//        my2.start();
        System.out.println(Thread.currentThread().getName());
    }
}

package com.gz_03;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<300;i++){
            System.out.println(getName()+"---------"+i);
        }
    }
    
    public  MyThread(){
        
    }
    
    public  MyThread(String name){
        super(name);
    }
}

线程调度：

假如我们的计算机只有一个CPU，那么CPU在某一个时刻只能执行一条指令，线程只有得到CPU的时间片，也就是使用权
才可以执行指令。那么java是如何对线程进行调用的呢？

线程有两种调度模型：
    分时调度模型：
        所有线程轮流使用CPU使用权，平均分配每个线程占用CPU的时间片
    抢占式调动模式：
        有限让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一点

        java使用的是抢占式调度模型

线程的优先级：

package com.gz_04;

public class ThreadPriority extends Thread{
    public void run(){
        for(int i=0;i<300;i++){
            System.out.println(getName()+"	"+i);
        }
    }
    
}
package com.gz_04;
/*
 *  int getPriority()   返回线程的优先级。
 *  void setPriority(int newPriority) 更改线程的优先级
 *  
 * 注意：
 *   优先级在线程的MAX_PRIORITY和MIN_PRIORITY之间。默认的是NORM_PRIORITY
 *   优先级的范围是：1~10，默认5
 *   线程优先级仅仅表示获取CPU时间片的几率，往往在多次运行更容易看到效果，因为线程调度存在随机性
 *  
 */
public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1=new ThreadPriority();
        ThreadPriority tp2=new ThreadPriority();
        ThreadPriority tp3=new ThreadPriority();
        
        tp1.setName("东方不败");
        tp1.setPriority(10);
        tp2.setName("岳不群");
        tp2.setPriority(1);
        tp3.setName("林平之");
//        tp1.setPriority(100);
        System.out.println(tp1.getPriority());
        System.out.println(tp2.getPriority());
        System.out.println(tp3.getPriority());
        System.out.println(Thread.MAX_PRIORITY);//10
        System.out.println(Thread.MIN_PRIORITY);//5
        System.out.println(Thread.NORM_PRIORITY);//1
        
        tp1.start();
        tp2.start();
        tp3.start();
    }
}

线程的休眠：

package com.gz_04;

import java.util.Date;

public class ThreadSleep extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i+"	日期："+(new Date()));
            //睡觉
            //困了，休息1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
package com.gz_04;
/*
 * static void sleep(long millis) 
 * 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
 */
 
public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1=new ThreadSleep();
        ThreadSleep ts2=new ThreadSleep();
        ThreadSleep ts3=new ThreadSleep();
        
        ts1.setName("A");
        ts2.setName("B");
        ts3.setName("C");
        ts1.start();
        ts2.start();
        ts3.start();
    }
}

停止、中断线程：

package com.gz_04;

import java.util.Date;

public class ThreadStop extends Thread{

    @Override
    public void run() {
        System.out.println("开始执行："+new Date());
        
        //我要休息10秒钟，亲，不要打扰我
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            System.out.println("线程被终止了");
        }
        System.out.println("结束执行："+new Date());
        
    }
}
package com.gz_04;
/*
 * public final void stop() :让线程停止，过时了，但是还可以使用
 * public void interrupt():中断线程.把线程的状态终止，并抛出一个InterruptedException
 */
public class ThreadStopDemo {
    public static void main(String[] args) {
        ThreadStop ts=new ThreadStop();
        ts.start();
        
        //你超过3秒不醒过来，我就停止你
        try {
            Thread.sleep(3000);
//            ts.stop();
            ts.interrupt();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
        }
        
    }
}

守护线程：

package com.gz_04;

public class ThreadDaemon extends Thread{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(getName()+"	"+i);
        }
    }
}
package com.gz_04;
/*
 * public final void setDaemon(boolean on):将该线程标记为守护线程
 * 当正在运行的线程都是守护线程的时候，java虚拟机退出。该方法在启动线程前调用
 */
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1=new ThreadDaemon();
        ThreadDaemon td2=new ThreadDaemon();
        
        td1.setName("关羽");
        td2.setName("张飞");
        Thread.currentThread().setName("刘备");
        
        td1.setDaemon(true);
        td2.setDaemon(true);
        
        td1.start();
        td2.start();
        
        for(int x=0;x<100;x++){
            System.out.println(Thread.currentThread().getName()+":"+x);
        }
        
    }
}

等待线程终止或者等待一段时间或线程终止，才往下执行：

package com.gz_04;
/*
 *  void join() 等待该线程终止。 
 *  void join(long millis)  等待该线程终止的时间最长为 millis 毫秒。 
         
          
 */
public class TetsThreadJoin {
    public static void main(String[] args) {
        ThreadJoin tj1=new ThreadJoin();
        ThreadJoin tj2=new ThreadJoin();
        ThreadJoin tj3=new ThreadJoin();
        
        tj1.setName("李渊");
        tj2.setName("李元霸");
        tj3.setName("李世民");
        
        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}
package com.gz_04;

public class ThreadJoin extends Thread{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(getName()+"	"+i);
        }
    }
}

礼让线程：

package com.gz_04;
/*
 * public static void yield():暂停当前正在执行的线程对象，并执行其他线程
 * 让多个线程的执行更和谐，但不能保证一人一次
 */
public class ThreadYieldDemo {
    public static void main(String[] args) {
        ThreadYield ty1=new ThreadYield();
        ThreadYield ty2=new ThreadYield();
        ty1.setName("A");
        ty2.setName("B");
        ty1.start();
        ty2.start();
    }
}
package com.gz_04;

public class ThreadYield extends Thread{
     @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
            Thread.yield();
        }
    } 
}

第二种多线程的方式：实现接口

package com.gz_05;

public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(getName()+":"+i);
        }
    }
}
/*
实现多线程的两种方式：
继承Thread类
    自定义对象继承Thread类
    重写run()
    创建自定义的的对象
    启动线程对象
    
    为什么要重写run()
        run()里封装的是被线程执行的代码
    启动线程对象使用的是哪个方法
        start()
    run()和start()的区别
        run()直接调用相当于普通方法
        start()相当于先启动线程，然后JVM调用run()
        
方式2：实现Runnable接口
A:自定义类MyRunnable实现Runnable接口
B:在MyRunnable里面重写run方法
C:创建MyRunnable对象
D:创建Thread对象，将MyRunnable对象做为构造方法参数传递
E:启动线程对象

问题：
    有了方式1，为什么还要方式2？
    A:可以避免由于java单继承带来的局限性
    B:适合多个相同程序的代码去处理同一个资源的情况，把线程同程序的代码、数据有效分离，较好的体现了面向对象的设计思想

*/
package com.gz_05;

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int x=0;x<100;x++){
            //由于实现接口的方式，就不能直接使用Thread类的方法，但是可以间接使用
            System.out.println(Thread.currentThread().getName()+":"+x);
        }
    }

}
package com.gz_05;
/*
 * 方式2：实现Runnable接口
 * 步骤：
 *         A:自定义类MyRunnable实现Runnable接口
 *         B:重写run()方法
 *         C:创建MyRunnable类的对象
 *         D:创建Thread类的对象，将C步骤的对象做为参数传递
 */
public class MyRunnableDemo {
    public static void main(String[] args) {
        MyRunnable my=new MyRunnable();
//        Thread t1=new Thread(my);
//        Thread t2=new Thread(my);
//        t1.setName("A");
//        t2.setName("B");
        Thread t1=new Thread(my,"A");
        Thread t2=new Thread(my,"B");
        t1.start();
        t2.start();
        
    }
}

卖票问题：

package com.test;
/*
 * 需求：
 *     某电影院正在上映贺岁大片，共有100张票，而它有3个售票窗口，请设计一个程序模拟该电影院售票
 *     两种方式实现：继承Thread类、实现Runnable接口
 */
public class Test01 {
    
    public static void main(String[] args) {
//        MyTicketThread mtt1=new MyTicketThread();
//        MyTicketThread mtt2=new MyTicketThread();
//        MyTicketThread mtt3=new MyTicketThread();
//        mtt1.setName("窗口1");
//        mtt2.setName("窗口2");
//        mtt3.setName("窗口3");
        MyTicket1Thread mt=new MyTicket1Thread();
        Thread mtt1=new Thread(mt,"窗口1");
        Thread mtt2=new Thread(mt,"窗口2");
        Thread mtt3=new Thread(mt,"窗口3");
        mtt1.start();
        mtt2.start();
        mtt3.start();
    }
}

class MyTicketThread extends Thread{
    private static int ticketCount=100;
    @Override
    public void run() {
        for(;ticketCount>0;ticketCount--){
            
            System.out.println(getName()+"卖票编号"+ticketCount);
        }
    }
}
class MyTicket1Thread implements Runnable{
    private int ticketCount=100;
//    public void run() {
//        for(;ticketCount>0;ticketCount--){
//            
//            System.out.println(Thread.currentThread().getName()+"卖票编号"+ticketCount);
//        }
//        
//    }
    @Override
    public void run() {
        /*
         * 通过加入延迟后发现了两个问题：
         * A:相同票卖了多次
         * B: 卖负票
         */
        while(true){
            if(ticketCount>0){
                //为了模拟真实场景，我们稍作休息
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在卖"+(ticketCount--)+"张票");
            }
        }
    }
    
}

卖票问题引发了同步问题：同步代码块与同步方法

package com.gz_06;
/*
 * 同步的特点：
 *         前提：
 *             多个线程
 *         解决问题的时候需要注意：
 *            多个线程使用的是同一个所对象
 *同步的好处
 *        同步的出现出现了解决多线程的安全问题
 *同步的弊端
 *        当线程相当多的时候，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
 *有同步代码块，也可以有同步方法
 *
 *同步方法就是指该方法的所有代码都是同步的
 *
 *格式：
 *        public synchronized void methodname(){
 *
 *        }
 *基本同步方法的锁是什么呢？
 *    判断方法：
 *        在调用同步方法之前也写一个同步代码块，然后两个同步的地方应该是选择关系，如果代码块的对象与同步方法的对象是一样的，那么数据就会实现同步。否则。。。
 *测试知道：它的同步锁对象是this，也就是它本身的对象
 *
 *static 同步方法的锁是什么呢？
 *测试知道：它的同步的锁是加载的Class对象，因为static是属于Class对象的
 **/
public class SellTicket implements Runnable{
    private static int tickets=100;
//    private Object obj=new Object();
    @Override
    public void run() {
//        while(true){
//            synchronized (obj) {
//                if(tickets>0){
//                    try {
//                        Thread.sleep(100);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
//                }else{
//                    break;
//                }
//            }
//        }
        while(true){
            int c=tickets%2;
            if(tickets==0){
//                    method1();
                method2();
            }else{
                    synchronized(SellTicket.class){
                        if(tickets>0){//刚才我将if判断放在同步锁外部，就出现了问题。以后判断还是要注意啊
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
                }
                }
            }
        }    
        
        
    }
    
    public synchronized void method1(){
            if(tickets>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
            }
        }
    
    public static synchronized void method2(){
        if(tickets>0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
        }
    }

}
package com.gz_06;

/*
 * 前面卖票问题我们知道是线程安全问题，如何解决呢？
 * 
 * 要想解决问题，就要知道哪些问题会导致出问题：（而且这些原因也是我们判断一个程序是否会有线程安全问题的标准）
 * A:是否是多线程环境
 * B:是否有共享数据
 * C:是否有多条语句操作共享数据
 * 
 * 我们来回想一下我们的程序
 *     A:是否多线程程序： 是
 *     B:是否有共享数据：是
 *     C:是否有多条语句操作共享数据：是
 * 
 * 由此可见，我们的程序出现问题是正常的，因为它满足出现问题的条件
 * 接下来才是我们想想如何解决问题呢？
 * 思想：
 *         把多条语句操作共享数据的代码给封装起来，一个线程访问的时候不允许其他线程访问
 * 怎么将语句封装起来呢？java提供了同步机制 
 * 
 * 同步代码块：
 *         synchronized(对象){
 *             需要同步的代码块
 *         }
 *         A：对象是什么呢？
 *             我们可以随便创建一个对象试试
 *         B:需要同步的代码是什么呢？
 *             把多条语句操作共享数据的代码包起来
 * 
 *         注意：
 * ·    ·    同步可以解决安全问题的根本就在哪个对象上。该对象相当于锁的功能
 *             要求多个线程使用同一把锁
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();
        Thread t1=new Thread(st,"窗口1");
        Thread t2=new Thread(st,"窗口2");
        Thread t3=new Thread(st,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
    
}

 JDK5加入了Lock类，形象的开锁与关锁：

package com.gz_01;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
 * 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，
 * 在哪里放了锁，为了更清晰的表达如何加锁和释放锁。JDK5以后提供了一个新的锁对象：LOCK
 * 
 * Lock
 *         void lock()
 *         void unlock()
 * ReentrantLock 是 Lock的实现类
 */
public class SellTicket implements Runnable{
    private int tickets=100;
    private Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while(true){
            lock.lock();
            try{
                if(tickets>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"正在出售第"+(tickets--)+"张票");
                }
            }finally{
                lock.unlock();
            }
            
        }
    }

}
package com.gz_01;

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();
        
        Thread t1=new Thread(st);
        Thread t2=new Thread(st);
        Thread t3=new Thread(st);
        
        t1.start();
        t2.start();
        t3.start();
    }
}

死锁：

package com.gz_02;
/*
 * 同步的弊端：
 *         效率低
 *         容易产生死锁
 * 死锁：
 *         两个或者俩个以上的线程在争夺资源的过程中发生的一种相互等待的现象
 *举例：
 *    中国人，美国人吃饭案例。
 *    正常情况：
 *        中国人：筷子两支
 *        美国人：刀和叉
 *    现在：
 *        中国人：筷子一支刀一把
 *        美国人：叉一把，筷子一支
 *        
 */
public class DieLockDemo {
    public static void main(String[] args) {
        DieLock dl1=new DieLock(true);
        DieLock dl2=new DieLock(false);
        dl1.start();
        dl2.start();
    }
}
package com.gz_02;

public class DieLock extends Thread{
    public boolean flag;
    public DieLock(boolean flag){
        this.flag=flag;
    }
    @Override
    public void run() {
        if(flag){
            synchronized(MyLock.objA){
                System.out.println("if objA");
                synchronized(MyLock.objB){
                    System.out.println("if objB");
                }
            }
        }else{
            synchronized(MyLock.objB){
                System.out.println("else objB");
                synchronized(MyLock.objA){
                    System.out.println("else objA");
                }
            }
        }
    }

}
package com.gz_02;

public class MyLock {
    public static final Object objA=new Object();
    public static final Object objB=new Object();
}

消费者生产者问题：

package com.gz_03;

public class GetThread implements Runnable{
    Student s;
    public GetThread(Student s){
        this.s=s;
    }
    @Override
    public void run() {
        
        System.out.println(s.name+"---"+s.age);
    }

}
package com.gz_03;

public class SetThread implements Runnable{
    private Student s;
    public SetThread(Student s){
        this.s=s;
    }
    
    @Override
    public void run() {
        s.name="林青霞";
        s.age=27;
    }

}
package com.gz_03;

public class Student {
    String name;
    int age;
}
package com.gz_03;
/*
 * 分析：
 *         资源类：学生
 *         设置学生数据：SetThread（生产者）
 *         获取学生数据：GetTread(消费者)
 *         测试类：StudentDemo
 * 
 * 问题1：按照思路写代码发现数据每次都是null---0
 * 原因是我们在getter和setter方法操作的对象是不一样的，我们要求获取和设置的线程资源应该是同一个
 * 如何实现呢？
 *         在2外界把这个数据创建出来，通过构造传递给其他的类
 * 
 */
public class StudentDemo {
    public static void main(String[] args) {
        Student s=new Student();
        SetThread st=new SetThread(s);
        GetThread gt=new GetThread(s);
        
        Thread t1=new Thread(st);
        Thread t2=new Thread(gt);
        
        t1.start();
        t2.start();
    }
}

使用线程通信方法：

package com.gz_04;

public class GetThread implements Runnable{
    Student s;
    public GetThread(Student s){
        this.s=s;
    }
    @Override
    public void run() {
        while(true){
            synchronized(s){
                if(!s.flag){
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(s.name+"---"+s.age);
                
                s.flag=false;
                s.notify();
            }
            
        }
        
    }

}
package com.gz_04;

public class SetThread implements Runnable{
    Student s;
    private int x=0;
    public SetThread(Student s){
        this.s=s;
    }
    @Override
    public void run() {
        while(true){
            synchronized(s){
                if(s.flag){
                    try {
                        s.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                if(x%2==0){
                    s.name="林青霞";
                    s.age=27;
                }else{
                    s.name="刘";
                    s.age=30;
                }
                x++;
                //修改标记
                s.flag=true;
                s.notify();
            }
            
        }
    }

}
package com.gz_04;

public class Student {
    String name;
    int age;
    boolean flag;//默认情况下是没有数据，如果为true说明有数据
}
package com.gz_04;
/*
 * 分析：
 *         资源类：学生
 *         设置学生数据：SetThread（生产者）
 *         获取学生数据：GetTread(消费者)
 *         测试类：StudentDemo
 * 
 * 问题1：按照思路写代码发现数据每次都是null---0
 * 原因是我们在getter和setter方法操作的对象是不一样的，我们要求获取和设置的线程资源应该是同一个
 * 如何实现呢？
 *         在外界把这个数据创建出来，通过构造传递给其他的类
 * 
 * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值，这个时候产生了新的问题
 *         A:同一个数据出现多次
 *         B:姓名和年龄不匹配
 * 原因：
 *         A:同一个数据出现多次
 *             CPU的一点点时间片的执行权，就足够执行很多次
 *         B:姓名和年龄不匹配
 *             线程运行的随机性
 * 线程安全问题：
 *         A:是否是多线程环境
 *         B:是否有共享数据
 *         C:是否有多条语句操作数据
 * 解决方案：
 *         同步锁
 * 注意：
 *         不同种类的线程都要枷锁
 *         必须加上同一把锁
 * 问题 
 * 
 * 问题3：虽然数据安全了，但是呢？一次一大片不太好看，我们希望的是依次的一次一个输出
 * 如何实现呢？
 *         通过Java提供的等待唤醒机制解决
 *             sleep();
 * 等待唤醒：
 *         Object类中提供了三个方法：
 *             wait()：等待,立即释放锁。将来醒过来的时候是从这里醒过来的
 *             notify():唤醒单个线程，唤醒并不表示拥有CPU执行权，这个还是要抢
 *             notifyAll():唤醒所有线程
 *         为什么这些方法不定义在Thread类中呢？
 *             这些方法的调用必须通过锁对象，而我们刚才使用的锁对象是任意锁对象，
 *             所以这些方法必须定义在Object类中
 *
 *补充：sleep方法不会释放锁
 */
public class StudentDemo {
    public static void main(String[] args) {
        Student s=new Student();
        SetThread st=new SetThread(s);
        GetThread gt=new GetThread(s);
        
        Thread t1=new Thread(st);
        Thread t2=new Thread(gt);
        
        t1.start();
        t2.start();
    }
}

优化后：

package com.gz_06;

public class GetThread implements Runnable{
    private Student s;
    public GetThread(Student s){
        this.s=s;
    }
    @Override
    public void run() {
        while(true){
            s.get();
        }
            
    }
}

package com.gz_06;

public class SetThread implements Runnable{
    private Student s;
    private int x=0;
    public SetThread(Student s){
        this.s=s;
    }
    @Override
    public void run() {
        while(true){
            //一个else引发的惨案
            //写程序的时候，我们必须明确我们的设计走，不能跟着想法走。
            //我在set方法的if判断后面加了else，就是wait和赋值是并列的，因为如果一直走wait的时候，x++还是走了，所以可能出现一直赋值同一个名字与姓名。看起来就像出现了线程安全问题
                if(x%2==0){
                    s.set("林青霞",27);
                }else{
                    s.set("刘",30);
                }
                x++;
        }
    }

}
package com.gz_06;

public class Student {
    private String name;
    private int age;
    private boolean flag;//默认情况下是没有数据，如果为true说明有数据
    
    public synchronized void set(String name,int age){
        if(this.flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
            this.name=name;
            this.age=age;
            this.notify();
            this.flag=true;
            
        
    }
    
    public synchronized void get(){
        if(!this.flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
            System.out.println(this.name+"---"+this.age);
            this.notify();
            this.flag=false;
            
        }
    
}
package com.gz_06;
/*
 * 分析：
 *         资源类：学生
 *         设置学生数据：SetThread（生产者）
 *         获取学生数据：GetTread(消费者)
 *         测试类：StudentDemo
 * 
 * 问题1：按照思路写代码发现数据每次都是null---0
 * 原因是我们在getter和setter方法操作的对象是不一样的，我们要求获取和设置的线程资源应该是同一个
 * 如何实现呢？
 *         在外界把这个数据创建出来，通过构造传递给其他的类
 * 
 * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值，这个时候产生了新的问题
 *         A:同一个数据出现多次
 *         B:姓名和年龄不匹配
 * 原因：
 *         A:同一个数据出现多次
 *             CPU的一点点时间片的执行权，就足够执行很多次
 *         B:姓名和年龄不匹配
 *             线程运行的随机性
 * 线程安全问题：
 *         A:是否是多线程环境
 *         B:是否有共享数据
 *         C:是否有多条语句操作数据
 * 解决方案：
 *         同步锁
 * 注意：
 *         不同种类的线程都要枷锁
 *         必须加上同一把锁
 * 问题 
 * 
 * 问题3：虽然数据安全了，但是呢？一次一大片不太好看，我们希望的是依次的一次一个输出
 * 如何实现呢？
 *         通过Java提供的等待唤醒机制解决
 * 
 * 等待唤醒：
 *         Object类中提供了三个方法：
 *             wait()：等待,立即释放锁。将来醒过来的时候是从这里醒过来的
 *             notify():唤醒单个线程，唤醒并不表示拥有CPU执行权，这个还是要抢
 *             notifyAll():唤醒所有线程
 *         为什么这些方法不定义在Thread类中呢？
 *             这些方法的调用必须通过锁对象，而我们刚才使用的锁对象是任意锁对象，
 *             所以这些方法必须定义在Object类中
 * 
 * 最终版中：
 *         把Student的成员变量给私有了
 *         吧设置和获取的操作封装成了功能并同步了
 *         设置或者获取线程里面只需要调用方法即可
 *
 *补充：sleep方法不会释放锁
 */
public class StudentDemo {
    public static void main(String[] args) {
        Student s=new Student();
        SetThread st=new SetThread(s);
        GetThread gt=new GetThread(s);
        
        Thread t1=new Thread(st);
        Thread t2=new Thread(gt);
        
        t1.start();
        t2.start();
    }
}

线程组：

package com.gz_05;
/*
 * 线程类里面的方法 public final ThreadGroup getThreadGroup()
 * 线程组里面的方法：public final String getName()
 * Thread(ThreadGroup tg,Runnable eun,String name)
 */
public class ThreadGroupDemo {
    public static void main(String[] args) {
        MyRunnable my=new MyRunnable();
        Thread t1=new Thread(my,"刘毅");
        Thread t2=new Thread(my,"林青霞");
        
        //线程类里面的方法 public final ThreadGroup getThreadGroup()
        ThreadGroup tg1=t1.getThreadGroup();
        ThreadGroup tg2=t2.getThreadGroup();
        
        //线程组里面的方法：public final String getName()
        System.out.println(tg2.getName());
        System.out.println(tg1.getName());
        
        System.out.println(Thread.currentThread().getThreadGroup().getName());
        
        //我们如何修改线程所在的组呢？
        //创建一个线程组
        //创建其他线程的时候，把其他线程的组指定为我们自己新建线程组
    }
    
    public static void method2(){
        ThreadGroup tg=new  ThreadGroup("tg");
        MyRunnable my=new MyRunnable();
        Thread t1=new Thread(tg, my, "刘毅");
        Thread t2=new Thread(tg, my, "林青霞");
        
        System.out.println(t1.getThreadGroup().getName());
        System.out.println(t2.getThreadGroup().getName());
        
        //通过组名设置守护线程
        tg.setDaemon(true);
    }
    
    
}
package com.gz_05;

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int x=0;x<100;x++){
            System.out.println(Thread.currentThread().getName()+":"+x);
        }
    }

}

线程池：ExecutorService

package com.gz_07;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * 线程池的好处：
 *         线程池里面的每一个线程代码结束之后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用
 * 
 * 如何实现线程的代码呢？
 *         A:创建一个线程池对象，控制要创建几个线程对象
 *             public static ExecutorService newFixedThreadPool（int nThreads）
 *         B:这种线程池的线程可以执行
 *             可以执行Runnable对象或者Callable对象代表的线程
 *             做一个Runable接口
 *         C:调用如下方法即可：
 *             Future<?> submit(Runnable task)
 *             <T> Future<T> submit(Callable<T> task)
 *
 *
 *我可以将线程池理解成为一个存放线程对象的集合。
 *它节省资源，使用submit方法可以装载线程得到并且运行
 *线程池中的线程执行完后不会被回收而是回到线程池
 *
 *
 */
public class ExecutorsDemo {
    public static void main(String[] args) {
        
        ExecutorService pool=Executors.newFixedThreadPool(2);
        
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        
        //结束线程池
        pool.shutdown();
    }
}
package com.gz_07;

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int x=0;x<100;x++){
            System.out.println(Thread.currentThread().getName()+"---"+x);
        }
    }

}

依赖于线程池的第三种多线程方式：Callable

package com.gz_08;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
 * 多线程实现的方式3：
 *     依赖于线程池实现
 * 
 * 
 * 
 */
public class CallableDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService es=Executors.newFixedThreadPool(2);
//        es.submit(new MyCallable());
//        es.submit(new MyCallable());
        
        Future<Integer> f1=es.submit(new MyCallable01(100));
        Future<Integer> f2=es.submit(new MyCallable01(10));
        
        Integer i1=f1.get();
        Integer i2=f2.get();
        
        System.out.println(i1);
        System.out.println(i2);
        es.shutdown();
    }
    
    
}
package com.gz_08;

import java.util.concurrent.Callable;

/*
 * Callable是泛型的
 * 这里指定的泛型其实是call()方法返回值类型
 */
public class MyCallable implements Callable{

    @Override
    public Object call() throws Exception {
        for(int x=0;x<100;x++){
            System.out.println(Thread.currentThread().getName()+"---"+x);
        }
        return null;
    }

}
package com.gz_08;

import java.util.concurrent.Callable;

//第三种方式线程求和
public class MyCallable01 implements Callable<Integer>{

    private int number;
    public MyCallable01(int number){
        this.number=number;
    }
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for(int x=0;x<=number;x++){
            sum+=x;
        }
        return sum;
    }

}

使用内部类的多线程练习：

package com.gz_09;

/*
 * 
 * 匿名内部类的格式
 *         new 类名或者接口名(){
 *             重写方法;
 *         };
 *         本质：是该类或者接口的子类对象
 */
public class ThreadDemo {
    public static void main(String[] args) {
        new Thread(){
            public void run(){
                for(int x=0;x<100;x++){
                    System.out.println(Thread.currentThread().getName()+":"+x);
                }
            }
        }.start();
        
        new Thread(new Runnable(){
            @Override
            public void run() {
                for(int x=0;x<100;x++){
                    System.out.println(Thread.currentThread().getName()+":"+x);
                }
            }
            
        }){}.start();
        
        //走的是下面的
        new Thread(new Runnable(){
            @Override
            public void run() {
                for(int x=0;x<100;x++){
                    System.out.println("hello"+":"+x);
                }
            }
            
        }){
            public void run(){
                for(int x=0;x<100;x++){
                    System.out.println("world"+":"+x);
                }
            }
        }.start();
    }
}

使用java定时器：Timer和TimerTask

package com.gz_10;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/*
 * 需求：在指定的时间删除我们的指定目录
 */
public class TestTimer {
    public static void main(String[] args) throws ParseException {
        Timer t=new Timer();
        String s="2016-06-14 15:18:00";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d=sdf.parse(s);        
        t.schedule(new DeleteFolder(), d);
    }
}
class DeleteFolder extends TimerTask{
    
    @Override
    public void run() {
        File srcFolder=new File("demo");
        deleteFolder(srcFolder);
        this.cancel();
    }

    public void deleteFolder(File srcFolder) {
        File[] fileArray=srcFolder.listFiles();
        if(fileArray!=null){
            for(File file:fileArray){
                if(file.isFile()){
                    
                    System.out.println(file.getName()+":"+file.delete());
                }else{
                    deleteFolder(file);
                }
            }
            System.out.println(srcFolder.getName()+":"+srcFolder.delete());
        }
    }
}
package com.gz_10;

import java.util.Timer;
import java.util.TimerTask;

/*
 * 定时器是一个应用非常广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。
 * 在java中，可以通过Timer和TimerTask类来实现定义调度的功能
 * 
 * Timer
 *         public Timer()
 *         public void schedule(TimerTask task,Long delay) 定时器在几秒后开始执行
 *         public void schedule(TimerTask task,Long delay,long period) 定时器在几秒后执行，然后在连环执行，执行的间隔为几秒
 * public void schedule(TimerTask task,Date d) 定时器在指定时间执行
 *
 *    TimerTask
 *        public abstract void run()定时器中要执行的代码
 *        public boolean cancel() 关闭定时器
 */
public class TimerDemo {
    public static void main(String[] args) {
        Timer t=new Timer();
        t.schedule(new MyTimerTask(), 3000);
        t.schedule(new MyTimerTask1(), 3000,1000);//三秒后地震开始，然后每秒余震一次
    }
}
class MyTimerTask extends TimerTask{

    @Override
    public void run() {
        System.out.println("beng，爆炸了");
        this.cancel();
    }
    
}
class MyTimerTask1 extends TimerTask{

    @Override
    public void run() {
        System.out.println("地震。。。");
    }
    
}