1.线程

1.线程的概念

1.线程是由进程创建的，是进程的一个实体

2.一个进程可以拥有多个线程

2.并发

​ *同一时刻，多个任务交替执行，造成一种"貌似同时"的错觉，单核cpu实现的多任务就是并发

3.并行

​ *同一时刻，多个任务同时执行，多核cpu可以实现并行

4.继承线程的两种方式

1.继承Thread类，重写run方法

public class Tread01 {
    main() {//主线程
        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();
        cat.run();//直接调用就是在main线程里面执行，执行完run方法才会继续向下执行
        cat.start();//启动子线程
    }
}

//当一个类继承了Thread类，该类就可以当成线程使用
class Cat extends Thread {
    @Override
    public void run() {//重写run方法，写上业务逻辑
        while(true) {
        		//该线程每隔1秒，控制台输出"喵喵，我是小猫咪"
        System.out.println("喵喵，我是小猫咪");
        try{
              Thread.sleep(1000);//休眠1秒  
        }catch(InterruptedException e) {
			e.printStackTrace();	
        }
        }
    }
}

2.实现Runnable接口，重写run方法

​ 1.java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时就不能通过继承Thread类方法来创建线程了

​ 2.提供了另外一个方式创建线程，实现Runnable接口来创建线程

public class Tread01 {
    main() {//主线程
        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();
        cat.run();//直接调用就是在main线程里面执行，执行完run方法才会继续向下执行
        //创建了Thread对象，把cat对象(实现了Runnable)放入Thread
        Thread thread = new Thread(cat);
        thread.start();
    }
}

//当一个类继承了Runnable接口，该类就可以当成线程使用
class Cat implements Runnable {
    @Override
    public void run() {//重写run方法，写上业务逻辑
        while(true) {
        		//该线程每隔1秒，控制台输出"喵喵，我是小猫咪"
        System.out.println("喵喵，我是小猫咪");
        try{
              Thread.sleep(1000);//休眠1秒  
        }catch(InterruptedException e) {
			e.printStackTrace();	
        }
        }
    }
}

5.线程终止

1.线程完成后，自动退出

2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

6.线程常用方法

1.setName

//设置线程名称，使之与参数name相同

2.getName

//返回该线程名称

3.start

//使该线程开始执行，Java虚拟机底层调用该线程的start0方法

4.run

//调用线程对象run方法

5.setPriority

//更改线程的优先级

6.getPriority

//获取线程的优先级

7.sleep

//在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

8.interrupt

//中断线程 一般用来中断线程休眠，让它继续运行

class T extends Thread {
    @Override
    public void run() {
        while(true) {
            for(int i =0;i<100;i++) {
                System.out.println(Thread.currentThread().getName())
            } try {
                System.out.println(Thread.currentThread().getNmae() + "休眠中");
                Thread.sleep(2000);//20秒
            }
        }
    }
}

main() {
    T t = new T();
    t.setNmae("qweq");
    t.setPriority(Thread.MIN_PRIORITY);
    t.start();
    
    for(int i=0;i<5;i++) {
        Thread.sleep(1000);
        System.out.println("hi"+i);
    }
    t.interrupt();//执行到这里时，就会中断t的休眠
}

9.yield

//让出cpu，让其他的线程执行，但礼让的时间不确定，所以也不一定礼让成功

//自身调用Thred.yield

10.join

//线程的插队，插队的线程一旦插队成功，则肯定先执行完插入的线程的所有任务

//别的调用t2.join

7.用户线程和守护线程

1.用户线程：也叫工作线程，当线程的任务执行完或通知方式结束

2.守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

3.常见的守护线程：垃圾回收机制

main() {
    MyDaemonThread myDaemonThread = new MyDaemonThread();
    //将子线程设为守护线程
    myDaemonThread.setDaemon(true);
    myDaemonThread.start();
}

8.线程7大状态

9.线程同步机制

1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性

2.线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，知道该线程完成操作

10.同步具体方法-Synchronized

1.同步代码块

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

2.synchronized还可以放在方法声明中，表示整个方法-为同步方法

public synchronized void m (String name) {

​	//需要被同步的代码

}

11.互斥锁

1.保证共享数据操作的完整性

2.每个对象都对应于一个可称为"互斥锁"的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象

3.关键字synchronized来与对象的互斥联系，当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问

4.同步局限性：导致程序的执行效率降低

5.同步方法(非静态的)的锁可以是this，也可以是其他对象(要求是同一个对象)

public void sell() {
	synchronized (this//或者 Object) {
        //执行代码
    }
}

public synchronized void sell() {
    //执行代码
}

6.同步方法(静态的)的锁为当前类本身

class SellTicket03 implements Runnable {
	public synchronized static void m1() {
		
    }
    
	public static void m2() {
		synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }
}

1.注意事项和细节

1.同步方法如果没有使用static修饰，默认锁对象为this

2.如果方法使用static修饰，默认锁对象：当前类.class

12.线程的死锁

​ *多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程需要避免