线程的问题

基本概念

并发：指两个或者多个在同一时间段内发生
并行：指两个或多个在同一时刻发生
进程：在计算机上运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程
线程：进程中的一个执行单元，负责当前进程中程序的执行，一个进程至少有一个线程
线程的调度：多个线程处于就绪状态等着CPU，JVM就负责线程的调度，JVM采取抢占式调度

继承Thread类的原理

1、Thread类就是线程类，规定了线程应该具备的属性和行为，继承了线程类就具备了这些功能
比如继承了Thread类就可以调用start方法，开启线程
2、为什么不直接创建Thread类对象，而是要继承呢？
Thread thread = new Thread();
thread.start（）
这样子就创建了一条线程，但是里面的run方法不是我们想要的，所以继承就是为了重写run方法
3、调用run方法程序还是单线程，调用start（）方法才可以实现多线程
4、线程一旦start开启，执行完毕，就完事了，不能多次调用start
5、线程内存解释：每个线程都有自己独立的栈空间，在main栈空间里面，遇到了线程，就要通知JVM开辟新的栈空间，并在新的空间里执行线程对象的run方法

创建线程类方法一

Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例
1、定义一个Thread类的子类，重写run（）方法，run（）方法代表了线程需要完成的任务，因此称run()方法为线程执行体
2、创建Thread子类的实例，即创建了线程对象
3、调用线程对象的start（）方法来启动该线程

//定义了一个Thread的子类，重写run方法
public class MyThread extends Thread{
    @Override
    public void run() {
        for(int i =0;i<6;i++){
            System.out.println("mythread"+i);
        }
    }
}

//创建线程对象，并且调用start方法
public static void main(String[] args) {
    MyThread myThread = new MyThread();
    myThread.start(); 
    //MyThread一个线程执行，main主线程也将继续执行，分别执行
    for(int i =0;i<6;i++){
        System.out.println("main"+i);
    }
}

Thread常用方法

getName（）获取线程的名字，没有办法获取到main方法的名字，因为main方法是static静态方法
setName（）设置线程的名字
Thread（String name）构造方法也可以设置线程的名字
static Thread currentThread（）获取当前线程对象，一般都是使用和这个方法，更加通用

 Thread thread =Thread.currentThread()
  thread.getName()  //通过这个方法可以获取main方法的名字

public static void sleep(long time) 让当前线程进入到睡眠状态，到毫秒后自动醒来继续执行

public void join（）调用这个方法的线程插队，此时的线程暂停

      MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.start();
        t1.join();//此时的方法是main方法，t1为调用的线程，所以t1插队，main方法要暂停，直到t1执行完成，然后main方法开始执行t2.start()
        t2.start();
        for(int i =0;i<10;i++){
            System.out.println("main"+i);
        }

public static boolean interrupted（）获取线程是否中断的状态，如果中断返回true，没中断返回false
public boolean isInterrupted（）判断当前线程是否中断
public void interrupt（）中断线程，不会直接停掉线程，但是自动调用interrupted方法，返回true

创建线程类方法二

1、定义一个类实现Runable接口
2、重写run（）方法
3、创建实现类对象（创建线程任务对象）
4、开启线程new Thread(线程任务).start()，构造方法的参数是线程任务对象

public class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i =0;i<6;i++){
            System.out.println("mythread"+i);
        }
    }
}

 public static void main(String[] args) {
        //线程任务对象
        MyThread myThread = new MyThread();
        //将线程任务对象传入给线程对象
       Thread thread= new Thread(myThread);
       thread.start();
      
    }

为什么有了继承方式还要有另一种方式？
1、java单继承，如果这个子类已经继承了其他的类，则不能再继承Thread，而Runable是实现接口，可以接口多实现
2、实现Runable接口方式，将线程和线程任务解耦
3、更容易实现线程任务共享，可以定义两个线程对象，都分别引用相同的线程任务，共享任务

匿名内部类创建线程

匿名内部类创建线程

public static void main(String[] args) {
    Thread thread =new Thread(){ //内部类
        @Override
        public void run(){
            System.out.println("线程");
        }
    };
    thread.start();
}

public static void main(String[] args) {
    Runnable runnable = new Runnable(){ //内部类
        @Override
        public void run(){
            System.out.println("线程");
        }
    };
    new Thread(runnable).start();
}

线程同步

含义：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作
方法一：线程同步：在方法（这里的方法一般都是将可能出现问题的代码块组成一个方法）的返回值类型之前，加上关键字synchronized

方法二：同步代码块
synchronized (任意对象，一般写this){
可能出现问题的代码，一般都是在run方法里面执行线程任务的代码
}

LOCK锁接口

比synchronized代码块和方法更广泛
常用方法：
void lock（）获取锁
void unlock（）释放锁
实现类：ReentrantLock

public class SellTicket implements Runnable {
    static int ticketNum = 100;
    Lock l = new ReentrantLock();

    @Override
    public void run() {
        while (ticketNum > 0) {
            l.lock();  //获取锁
            try {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + "卖票了" + ticketNum);
                ticketNum--;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                l.unlock(); //释放锁，防止不能释放锁，所以放在finally里面
            }
        }

    }
}

notify（）和wait（）方法

wait()方法：导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。

wait（）和sleep()的区别：

sleep（）是Thread的静态方法，既可以在同步中使用，也可以在同步外使用，在同步中使用的时候，线程遇到sleep（）不释放锁，时间到了，继续向下执行
wait（）是Object类的方法，只能在同步中使用，由对象监视器调用，当线程遇到wait进入到等待状态是，会释放掉锁，wait（）必须有人通过notify或者notifyAll唤醒

notify（）方法：唤醒正在等待对象监视器的单个线程。
notifyAll（）方法：唤醒正在等待对象监视器的全部线程。

public static void main(String[] args) {
        Object obj = new Object();
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (obj) {
                    System.out.println("开始等待");
                    try {
                        obj.wait(); //wait方法必须是和锁对象
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("结束等待");
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
              synchronized(obj){
                  try {
                      Thread.sleep(2000); //停留两秒之后再打印“结束等待”
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
                  obj.notify();//wait()和 notify()的方法必须是同一个对象才能唤起wait方法的等待
              }
            }
        }).start();
    }
}

线程的状态

枚举Thread.State

线程状态	导致状态发生条件
NEW 新建	线程刚被创建，但是未启动，还没有调用start()方法
Runable可运行	线程可以在jav虚拟机中运行的状态，可能正在运行自己的代码，也可能没有，这取决于操作系统的处理器
Blocked锁阻塞	当一个线程师徒获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态，当该线程持有锁的时候，状态变为Runable状态
Waiting无线等待	一个线程在等待另一个线程执行（唤醒）动作时，该线程进入Waiting状态，进入这个状态后是不能自动唤醒的，必须等另一个线程 调用notify或notifyAll方法才能够唤醒
Timed Waiting计时等待	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态，这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Terminated被终止	因run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡