java中的线程

知识模块
一.进程和线程概述：
二.创建线程的第一种方式
三.Thread类的常用方法
四.创建线程的第二种方式
五.第三种创建方式
六.多线程安全问题




一.进程和线程概述：
    进程：操作系统中运行的程序对应一个或多个进程
    线程：一个进程中至少有一个线程，线程控制着进程的执行

二.创建线程的第一种方式
     //线程定义
        class 类名 extends Thread{
            public void run(){
                //定义线程要执行的程序
            }
        }
    /* 创建线程并启动*/
    创建该类对象然后调用start()方法

/*
自定义线程
 */
public class Thread01 extends Thread {
    public void run() {
        //线程要执行的任务
        for (int i = 0; i < 10; i++) {
            System.out.println("run..."+i);
        }
    }
}

/*
自定义线程
参照自定义异常思想
class AgeException extends Exception/RuntimeException{

}
class Dog extends Animal{

}
  同理可得
  class 类名 extends ？？？{

  }
  多线程运行特点：
     CPU在多个线程之间做着随机切换执行操作，无论如何切换，最终一定会把每个线程
     任务执行完
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        Thread01 t1 = new Thread01();
        //t1.run();t1.run()仅仅相当于通过对象调用方法，不会去创建一个线程
        t1.start();//创建一个线程并启动

        for (int i = 0; i < 10; i++) {
            System.out.println("main..." + i);
        }
    }
}

三.Thread类的常用方法
      Thread类中的方法
          static Thread currentThread()
                获取当前执行的线程对象
          String getName()
                底层再给线程起名的时候默认是从0开始
                Thread-0，Thread-1....
          static void sleep(long millis)
                可以让指定的线程休眠指定的毫秒值，当指定的毫秒值时间一到，该线程会自动醒来
                当CPU再次切换到该线程的时候，会继续执行

/*
自定义线程
缺点：
class A extends B,Thread{//Java不支持多继承

}


 */
public class Thread01 extends Thread {
    public void run() {
        //线程要执行的任务
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"..."+i);
        }
    }
}

/*
Thread类中的方法
    static Thread currentThread()
          获取当前执行的线程对象
    String getName()
          底层再给线程起名的时候默认是从0开始
          Thread-0，Thread-1....
    static void sleep(long millis)
          可以让指定的线程休眠指定的毫秒值，当指定的毫秒值时间一到，该线程会自动醒来
          当CPU再次切换到该线程的时候，会继续执行
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        Thread01 t1 = new Thread01();
        //t1.run();t1.run()仅仅相当于通过对象调用方法，不会去创建一个线程
        t1.start();//创建一个线程并启动

        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"..." + i);
        }
    }
}

四.创建线程的第二种方式
    class 类名 implemetns Runnable{
        public void run(){
          //定义线程要执行的任务
        }
    }
    /* 创建该线程并启动*/
    new Thread（new 类名()）.start();

public class Thread01 implements Runnable {

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

/*
Thread类的构造方法
    Thread(Runnable target)
          分配新的 Thread 对象。
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        Thread01 t1 = new Thread01();
        new Thread(t1).start();//new Thread()创建线程对象
                               //t1实现了Runnable接口，重写了run()方法，传给Thread()构造方法，相当于将线程要执行的任务传递给该线程
                               //最后调用start()方法会在底层创建并启动该线程
        new Thread(t1).start();//又创建一个新的线程，执行的还是一样的任务
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "... " + i);
        }
    }
}

五.第三种创建方式
       线程第三种创建方式：匿名内部类
       格式：
           new 父类/父接口(){
             //重写父类或父接口的方法
           };
           原理：
             父类
              class 类名 extends 父类{
                 //重写父类的方法
              }
              new 类名();
             父接口
              class 类名 implement 父接口{
                 //实现父接口方法
              }
              new 类名();
       实现代码1：
       new Thread() {
                  public void run() {
                      for (int i = 0; i < 10; i++) {
                          System.out.println(getName() + "..." + i);
                      }
                  }
              }.start();

       实现代码2：
       new Thread(new Runnable() {
                   public void run() {
                       for (int i = 0; i < 10; i++) {
                           System.out.println(Thread.currentThread().getName() + " " + i);
                       }
                   }
               }).start();

/*
线程第三种创建方式：匿名内部类
格式：
    new 父类/父接口(){
      //重写父类或父接口的方法
    };
    原理：
      父类
       class 类名 extends 父类{
          //重写父类的方法
       }
       new 类名();
      父接口
       class 类名 implement 父接口{
          //实现父接口方法
       }
       new 类名();

 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        //method01();
        /*
         class 类名 implemetns Runnable{
        public void run(){
          //定义线程要执行的任务
        }
    }
          new Thread（new 类名()）.start();
         */
      /*  Runnable r = new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
            }
        };
        new Thread(r).start();*/

        new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
            }
        }).start();

       /* new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + " " + i);
                }
            }
        }).start();*/

    }

    private static void method01() {
    /*  //线程定义
      class 类名 extends Thread{
          public void run(){
              //定义线程要执行的程序
          }
      }*/
        /*Thread t = new Thread() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(getName() + "..." + i);
                }
            }
        };
        t.start();*/
        new Thread() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(getName() + "..." + i);
                }
            }
        }.start();
    }
}

六.多线程安全问题
   a.产生原因
       由于多个线程操作同一份共享资源，其中一个线程还没有执行完操作共享数据的代码，CPU切换到
       其他线程去执行，最终导致共享数据报错误

public class Ticket implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        //卖票
        while (true) {
            if (ticket>0) {
             /*   try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
               // System.out.println(Thread.currentThread().getName()+"..."+ticket--);
                System.out.println(Thread.currentThread().getName()+"..."+ticket);
                ticket--;
            }
        }
    }
}

/*
多线程卖票：
 三个窗口去卖100张票
 A窗口    B窗口    C窗口
 100      98       95
 99       97       94
          96
  ..      ..       ..
  我们考虑用线程去模拟窗口，线程执行任务为卖票(输出语句)

  卖票案例的第一个问题：
     1.卖出0票和-1票
     2.卖出重复票
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t,"A窗口").start();//模拟窗口A
        new Thread(t,"B窗口").start();//模拟窗口B
        new Thread(t,"C窗口").start();//模拟窗口C
    }
}

   b.解决方案
       1.同步代码块：保证其中一个线程在操作共享数据的时候不被其他线程打扰
              保证多线程操作共享资源的安全性
              使用同步代码块保证多线程安全性
              格式：
                synchronized(锁对象){
                   我们一般将操作共享资源的代码梵高同步代码块中
                }
                 锁对象指的是new出来的任意对象
                 1.如果某个线程进入同步代码块，该线程会持有该锁对象，其他线程就无法在进入同步代码块同时也无法持有该锁对象
                 2.如果某个线程走出同步代码块，该线程会释放该锁对象，此时其他某一个线程可以进入同步代码块同时可以持有该锁对象

                 注意：
                    所有的线程享有同一个锁对象才能保多线程操作共享资源安全性

public class Ticket implements Runnable {
    private int ticket = 100;

    @Override
    public synchronized void  run() {
        //卖票
        while (true) {

                if (ticket>0) {

                    System.out.println(Thread.currentThread().getName()+"..."+ticket--);
                }
            }
    }
}

/*
保证多线程操作共享资源的安全性
使用同步代码块保证多线程安全性
格式：
  synchronized(锁对象){
     我们一般将操作共享资源的代码梵高同步代码块中
  }
   锁对象指的是new出来的任意对象
   1.如果某个线程进入同步代码块，该线程会持有该锁对象，其他线程就无法在进入同步代码块同时也无法持有该锁对象
   2.如果某个线程走出同步代码块，该线程会释放该锁对象，此时其他某一个线程可以进入同步代码块同时可以持有该锁对象

   注意：
      所有的线程享有同一个锁对象才能保多线程操作共享资源安全性
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t,"A窗口").start();//模拟窗口A
        new Thread(t,"B窗口").start();//模拟窗口B
        new Thread(t,"C窗口").start();//模拟窗口C
    }
}

       2.同步方法：
              同步方法解决多线程安全问题：
               格式：
                   修饰符 synchronized 返回值类型 方法名(参数列表){

                   }
                   同步方法相当于：
                   synchronized(this){//this引用指向new Thread()中传入的对象
                      //对方法中所有代码同步
                   }
                   我们一般将涉及到操作共享数据的方法单独抽取到一个方法中，然后在这个方法上加synchronized

/*
同步方法解决多线程安全问题：
 格式：
     修饰符 synchronized 返回值类型 方法名(参数列表){

     }
     同步方法相当于：
     synchronized(this){//this引用指向new Thread()中传入的对象
        //对方法中所有代码同步
     }
     我们一般将涉及到操作共享数据的方法单独抽取到一个方法中，然后在这个方法上加synchronized
 */
public class ThreadDemo01 {
    public static void main(String[] args) {
        Ticket t = new Ticket();
        new Thread(t,"A窗口").start();//模拟窗口A
        new Thread(t,"B窗口").start();//模拟窗口B
        new Thread(t,"C窗口").start();//模拟窗口C
    }
}

public class Ticket implements Runnable {
    private int ticket = 100;

    /*@Override
    public synchronized void  run() {
        //卖票
        while (true) {

                if (ticket>0) {

                    System.out.println(Thread.currentThread().getName()+"..."+ticket--);
                }
            }
    }*/
  /*  @Override
    public void run() {
        synchronized (this) {
            System.out.println(this);

            //卖票
            while (true) {

                if (ticket > 0) {

                    System.out.println(Thread.currentThread().getName() + "..." + ticket--);
                }
            }
        }
    }*/
    public void run() {
            while (true) {
                sellTicket();
            }
        }

    private synchronized void sellTicket() {
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "..." + ticket--);
        }
    }
}