Thread（线程）多线程

多线程的优缺点（讲人话就是）

优点：提高了资源利用率，提高了用户体验
缺点：降低了其他线程的执行概率，会使用户使用体验变差，共享资源冲突，线程冲突，线程安全
（大白话：就是这玩意不能太多，太多不好，找到适当的线程数能够提高工作效率）

创建自定义线程类的两种方式

1.第一就是自己创建一个类然后继承Thread类，然后重写父类中的run方法
2.第二就是自己创建一个类实现Runnable接口，成为实现类完成run方法的重写
tips：我们需要通过自定义线程类对象，或者实现类类对象调用start方法，开启线程
自定义线程执行的流程：
程序执行–》main线程中–》自定义线程启动（如果没有自定义线程继续执行main线程里面的程序）》自定义线程开启执行自定义线程里面的程序》程序执行完毕
Thread的四种构造方法
第一种：Thread();分配一个新的线程对象，无目标，无指定名字
第二种：Thread(String name);创建一个指定名字的线程对象，无指定名字
第三种：Thread(Runnable target);创建一个新的线程对象，以Ruannable接口的实现类对象作为执行的线程代码块目标
第四种：Thread(Runnable target , String name);创建一个新的线程对象，以Runnable接口的实现类对象作为执行线程的代码块目标，指定一个名字
成员方法：void setName(String name);
String getName();
线程名字的getter和setter方法
void setPriority(int Priority);
设置线程的优先级，非一定执行要求增加执行的概率
int getPriority();
获得线程的优先级
void start();
启动线程对象
两个静态的成员方法
1.public static void sleep(int ms);
静态方法通过类名直接调用，当前所在代码块进入休眠状态，指定休眠毫秒数
2.public static Thread currentThread();
当前方法是静态方法，通过Thread类直接调用，获取当前所在代码块对应的线程对象

多线程的安全问题和解决方案

同步方法

我们需要用synchronized 作为关键字来修饰方法，修饰的方法就是对应的同步方法，有且只允许一个线程进入
选择同步方法是否使用static修饰的问题
1.如果非static修饰，要保证执行的线程对象有且只有一个，因为锁对象就是当前对象
2.如果是static修饰的，锁对象具有唯一性，多个线程使用的锁是同一个锁
（总结：唯一性，没有被static修饰的要保证线程对象的唯一性，反之需要保证锁对象的唯一性）

package com.qfedu.b;

class MyThread3 implements Runnable {
	private static int ticket = 100;

	@Override
	public void run() {
		while (true) {
				
				sellTicket();
				if (ticket ==0) {
					break;
				}
			
		
		}

	}
	//完成一个静态的由synchronized作为关键字修饰的静态同步方法
	public static synchronized void sellTicket() {
		if (ticket > 0) {
			System.out.println(Thread.currentThread().getName() + ticket + "张");
			ticket--;
		} else {
			System.out.println(Thread.currentThread().getName() + "售罄");
			
		}
	}

	

}

public class Demo3 {
	public static void main(String[] args) {
		Thread thread = new Thread(new MyThread3(), "美团");
		Thread thread2 = new Thread(new MyThread3(), "淘宝");
		Thread thread3 = new Thread(new MyThread3(), "大麦");
		thread.start();
		thread2.start();
		thread3.start();
	}
}

Lock锁

创建Lock构造方法
Lock lock = new ReentrantLock();
方法化操作：
开锁：
unlock()；
加锁:
lock();

package com.qfedu.b;

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

/**
 * 自定义销售线程
 * @author lqq
 *
 */
class singleThread implements Runnable{
	//共享资源
	private static int ticket= 100;
	//定义一个成员变量
	static Lock lock = new ReentrantLock();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
			
		
		while(true) {
			lock.lock();
				
			if (ticket > 0) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"售出了"+ticket+"张票");
				ticket -=1;
			}else {
				System.out.println(Thread.currentThread().getName()+"售罄");
				break;
			}
			lock.unlock();
			
		}
		
	}
	
}
public class Dome1 {
public static void main(String[] args) {
	Thread thread1 = new Thread(new singleThread(),"淘票票");
	Thread thread2 = new Thread(new singleThread(),"猫眼");
	Thread thread3 = new Thread(new singleThread(),"美团");
	thread1.start();
	thread2.start();
	thread3.start();
}
}

同步代码块

synchronized (/* 锁对象 */) {

}

/*
特征:
1. synchronized 小括号里面的对象是锁对象，并且要求如果是多线程的情况下，锁对象必须是同一个对象。
2. synchronized 大括号中的代码块就是需要进行同步的代码，或者说是加锁的代码，大括号里面的内容，有且只允许一个线程进入。
3. 同步代码块越短越好，在保证安全的情况下，提高性能

问题:
1. 目前锁对象感觉很随意，存在一定的隐患
2. 代码层级关系很复杂，看着有点麻烦
*/
三种加锁方式的总结
一锁一线程，一锁多线程问题
使用对应的锁操作对应的线程，考虑静态和非静态问题
同步方法和Lock锁使用

守护线程

守护线程也被称为后台线程，主线程结束，守护线程也会随之消失
通过方法获得守护线程对象
setDeamon(boolean flag);
true为守护线程
false缺省属性，正常线程

线程状态

NEW（新建）线程刚刚被创建，没有启动，没有调用start方法
RUNNABLE(可运行)线程已经在jvm中，但是是否运行不确定，看当前线程是否拥有cpu执行权
BLOCKED(锁阻塞)当前线程进入一个同步代码需要获取锁对象，但是发现当前锁对象被其他线程持有，当前线程会进入BLOCKED.如果占用锁对象线程打开锁，当前线程就会持有锁对象，进入RUNNABLE状态
WAITING(无限等待状态)通过一个wait方法进入无限等待状态，这里需要另一个线程进行唤醒操作，进入无限等待状态的线程无法自己回答RUNNABLE状态，需要通过其他线程来唤醒
TIMED_WAITING(计时等待)当前线程的确是等待状态，但在一定时间后会恢复Runnable状态Thread.sleep()或是Object类内的wait（int ms）。

TERMINATED(被终止)因为Run方法运行结束正常退出线程，或者说在运行的过程中因为出现异常导致当前线程GG思密达