Java基础----线程基础笔记

1、线程介绍

1. 程序（program）
   是为了完成特定任务、用某种语言编写的一组指令的集合。
2. 进程
   1. 进程是指运行中的程序，比如使用QQ就启动了一个进程，操作系统就会为该进程分配内存空间，当使用迅雷的时候，又启动了一个进程，操作系统也将为迅雷分配内存空间
   2. 进程是程序的一次执行过程，或是正在运行的一个程序。是动态的过程：有它自身的产生、存在和消亡的过程。
3. 线程
   线程由进程创建的，是进程的一个实体，一个进程可以拥有多个线程
4. 单线程：同一时刻，只允许执行一个线程
5. 多线程：同一时刻，可以执行多个线程
6. 并发：同一时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单地说，单核cpu是西安的多任务就是并发
7. 并行：同一时刻，多个任务同时进行，多核cpu可以实现并行

2、线程使用

1. 在java中创建线程的两种方式：
   1. 继承Thread类，重写run方法
   2. 实现Runnable接口，重写run方法
      
2. 继承Thread类，重写run方法的使用

public class Thread01 {
    
    
    public static void main(String[] args) {
    
    
        //创建一个Cat对象，可以当作线程使用
        Cat cat = new Cat();
        cat.start();//启动线程->最终会执行cat的run方法
        //说明：当main线程启动一个子线程，主线程不会阻塞
    }
}
//当一个类继承了Thread类，该类就可以当做线程使用
//Thread类中的run方法是实现了Runnable接口的run方法
class Cat extends Thread{
    
    
    @Override
    public void run() {
    
    //重写run方法，
        while (true){
    
    
            System.out.println("hahahahaha");
            System.out.println("线程名="+Thread.currentThread().getName());
            //让该线程休眠1s
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }

    }
}

3. 实现Runnable接口，重写run方法的使用
   Java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了

public class Thread02 {
    
    
    public static void main(String[] args) {
    
    
        Dog dog = new Dog();
        //dog.start();这里没有start，不能调用start开启线程
        //创建了Thread对象，把dog对象（实现Runnable）放入Thread，这里的底层使用了设计模式中的静态代理
        Thread thread = new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable{
    
    
    int count = 0;

    @Override
    public void run() {
    
    
        while(true){
    
    
            System.out.println("哈哈哈哈  "+count++);
            System.out.println("线程名"+Thread.currentThread().getName());
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            if(count>=10){
    
    
                break;
            }
        }

    }
}

模拟Thread的静态代理设计模式：

//模拟了Thread
class ThreadProxy implements Runnable{
    
    
    private Runnable target = null;
    @Override
    public void run() {
    
    
        if (target != null) {
    
    
            target.run();
        }
    }
    //构造器
    public ThreadProxy(Runnable target) {
    
    
        this.target = target;
    }
    public void start(){
    
    
        start0();
    }
    public void start0(){
    
    

    }
}

开启多个线程：

public class Thread03 {
    
    
    public static void main(String[] args) {
    
    
        Dog1 dog1 = new Dog1();
        Dog2 dog2 = new Dog2();
        Thread thread1 = new Thread(dog1);
        Thread thread2 = new Thread(dog2);
        thread1.start();
        thread2.start();
    }
}
class Dog1 implements Runnable{
    
    
    int count = 0;
    @Override
    public void run() {
    
    
        while(true){
    
    
            System.out.println("11111  "+count++);
            System.out.println("线程名"+Thread.currentThread().getName());
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            if(count>=10){
    
    
                break;
            }
        }

    }
}
class Dog2 implements Runnable{
    
    
    int count = 0;
    @Override
    public void run() {
    
    
        while(true){
    
    
            System.out.println("2222222  "+count++);
            System.out.println("线程名"+Thread.currentThread().getName());
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            if(count>=10){
    
    
                break;
            }
        }

    }
}

4. 通知线程退出：

public class Thread02 {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Dog dog = new Dog();
        Thread thread = new Thread(dog);
        thread.start();
        Thread.sleep(5000);
        //如果希望main线程去控制子线程终止，可以修改loop
        dog.setLoop(false);
    }
}
class Dog implements Runnable{
    
    
    int count = 0;
    private boolean loop=true;
    @Override
    public void run() {
    
    
        while(loop){
    
    
            System.out.println("哈哈哈哈  "+count++);
            System.out.println("线程名"+Thread.currentThread().getName());
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            if(count>=10){
    
    
                break;
            }
        }

    }
    public  void setLoop(boolean loop){
    
    
        this.loop = loop;
    }
}

3、线程常用方法

1. setName：设置线程名称，使之与参数name相同
2. getName：返回线程的名称
3. start：使线程开始执行，Java虚拟机底层调用该线程的start0方法
4. run：调用线程对象run方法
5. setPriority：更改线程的优先级
6. getPriority：获取线程的优先级
7. sleep：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
8. interrupt：中断线程
9. yield：线程的礼让。让出cpu，让其他线程先执行，但礼让的时间不确定，所以不一定礼让成功
10. join：线程的插队，插队的线程一旦插队成功，则肯定先执行完插入的线程的任务

public class Thread04 {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        Cat1 cat1 = new Cat1();
        cat1.start();
        for (int i = 1; i <= 10; i++) {
    
    
            System.out.println("主线程吃包子"+i);
            Thread.sleep(1000);
            if (i == 5) {
    
    
                cat1.join();//线程插队，这里相当于让cat1线程先执行完
//                Thread.yield();//礼让，资源多的时候一般礼让不成功
                System.out.println("子线程先完吃包子----------");
            }
        }
    }
}
class Cat1 extends Thread{
    
    
    private int n = 0;

    @Override
    public void run() {
    
    
        while (true){
    
    
            System.out.println("子线程吃包子"+ ++n);
            try {
    
    
                Thread.sleep(1000);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            if (n >=10) {
    
    
                break;
            }
        }
    }
}

注意事项：

1. start底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新的线程
2. 线程优先级的范围
3. interrupt中断线程，但并没有正在的结束线程；所以一般用于中断正在休眠线程
4. sleep：线程的静态方法，使当前线程休眠

11. 用户线程和守护线程
    1. 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
    2. 守护线程：一般是为用户线程服务的，当所有的用户线程结束，守护线程自动结束，myDaemonThread.setDaemon(true);将线程设为守卫线程
    3. 常见的守护线程：垃圾回收机制

将子线程设置为守卫线程：

public class Thread05 {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果希望当主线程结束，子线程可以自动退出，只需将子线程设为守卫线程（先设置，再退出）
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();

        for (int i = 0; i < 10; i++) {
    
    
            System.out.println("lalallaaa");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread{
    
    
    @Override
    public void run() {
    
    
        while(true){
    
    
            System.out.println("hahahhahah.....");
            try {
    
    
                Thread.sleep(500);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

4、线程生命周期

1. 在官方文档中线程有六种状态：
   
   

5、线程同步机制（Synchronized）

1. 在多线程编程，一些敏感数据不允许被多个线程访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性
2. 也可以理解为：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
3. 同步具体方法：Synchronized
   （1）同步代码块

synchronized(对象){
    
    //得到对象的锁，才能操作同步代码块
	//需要被同步代码；
}

（2）可以放在方法声明里，表示整个方法为同步方法

public synchronized void xxx(){
    
    
	//需要被同步代码；
}

避免售票出现负数：

public class Thread06 {
    
    
    public static void main(String[] args) {
    
    
        SellTicket01 sellTicket01 = new SellTicket01();
        new Thread(sellTicket01).start();//开启第一个线程-窗口
        new Thread(sellTicket01).start();//开启第二个线程-窗口
        new Thread(sellTicket01).start();//开启第三个线程-窗口
    }
}
class SellTicket01 implements Runnable{
    
    
    private int ticketNum = 50;//让多个线程共享ticketNum
    private boolean loop =true;
    public synchronized void sell(){
    
    //同步方法，在同一时刻，只允许有一个线程来执行sell方法
        if (ticketNum<=0){
    
    
            System.out.println("售票结束。。。。");
            loop =false;
            return;
        }
        try {
    
    
            Thread.sleep(1000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
        System.out.println("还剩"+ --ticketNum+"张票");
    }

    @Override
    public void run() {
    
    
        while(loop){
    
    
            sell();

        }
    }
}

6、互斥锁和线程死锁

1. 互斥锁基本介绍
   1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性
   2. 每一个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象
   3. 关键字synchronized来于对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能有一个线程访问
   4. 同步的局限性：导致程序的执行效率要降低
   5. 同步方法（非静态的）的锁可以时this，也可以时其他对象（要求是同一个对象）
   6. 同步方法（静态的）的锁为当前类本身
2. 互斥锁注意事项和细节
   1. 同步方法如果没有使用static修饰，默认锁对象为this
   2. 如果方法使用static修饰，默认锁对象：当前类.class
   3. 实现的落地步骤：
      1. 需要先分析上锁的代码
      2. 选择同步代码块或同步方法
      3. 要求多个线程的锁对象为同一个即可
3. 线程死锁：多个线程都占用了对方的锁资源，但不肯互让，导致死锁
   如：

public class Thread07 {
    
    
    public static void main(String[] args) {
    
    
        DeadLockDemo deadLockDemo = new DeadLockDemo(true);
        DeadLockDemo deadLockDemo1 = new DeadLockDemo(false);
        deadLockDemo.start();
        deadLockDemo1.start();
    }
}
class DeadLockDemo extends Thread{
    
    
    static Object o1 = new Object();//保证多线程，共享一个对象，这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
    
    
        this.flag = flag;
    }

    @Override
    public void run() {
    
    
        //如果flag为T，线程就会先得到o1对象锁，然后尝试去获取o2对象锁
        if (flag) {
    
    
            synchronized (o1){
    
    
                System.out.println("进入1");
                synchronized (o2){
    
    
                    System.out.println("进入2");
                }
            }
        }else{
    
    
            synchronized (o2){
    
    
                System.out.println("进入3");
                synchronized (o1){
    
    
                    System.out.println("进入4");
                }
            }
        }
    }
}

4. 下面操作会释放锁

   1. 当前线程的同步方法、同步代码块执行结束
   2. 当前线程在同步代码块、同步方法中遇到break、return
   3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
   4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

5. 下面操作不会释放锁

   1. 线程执行同步代码块、同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
   2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将线程挂起，该线程不会释放锁