1.什么是线程
线程是计算机能过进行运算调度的最小单位，也是程序运行的最小单位，任务调度由时间片论转的调度方式交替运算。
2.线程和进程的区别
（1）线程是程序执行的最小单位，进程是一个计算过程或者是一个任务。
（2）一个进程可以分配多个线程运行。
3.线程的状态
（1）创建状态：当用new操作符创建一个新线程时，这个线程还没开始运行，还处于创建状态。
（2）就绪状态：就绪状态就是可以运行，但还没有开始执行。当调用线程的start()方法，此线程进入就绪状态。当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
（3）阻塞和等待状态：当线程处于阻塞状态或者等待状态，线程暂时是非活动的，只有当满足某条件下才继续运 行。例如获取一个对象锁的时候没其他线程占用了，就会进入等待状态直到其他线程释放锁。
4.如何创建线程
1.继承Thread类实现
public class TextThread extends Thread {
public TextThread(){}
public void run(){}//重写run方法
}
public static void main(String[] args) {
TextThread Thread1=new TextThread();
TextThread Thread2=new TextThread();
TextThread Thread3=new TextThread();
Thread1.start();
Thread2.start();
Thread3.start();
}
2.实现Runnable接口
public class TextRunnable implements Runnable{
public void run(){}//重写run方法
public static void main(String[] args) {
TextRunnable runnable=new TextRunnable();
Thread Thread1=new Thread(runnable,"A");
Thread Thread2=new Thread(runnable,"B");
Thread Thread3=new Thread(runnable,"B");
Thread1.start();
Thread2.start();
Thread3.start();
}
3.实现Callable接口
与上面两种方式不同，callable可以有返回值。
public class TextCallable implements Callable<String>{
@Override
public String call(){//实现方法
return new String();
}
}
public static void main(String[] args) {
Callable<String> callable=new TextCallable();
FutureTask<String> futureTask1 = new FutureTask<>(callable);
FutureTask<String> futureTask2 = new FutureTask<>(callable);
FutureTask<String> futureTask3 = new FutureTask<>(callable);
Thread Thread1=new Thread(futureTask1,"A");
Thread Thread2=new Thread(futureTask2,"B");
Thread Thread3=new Thread(futureTask3,"B");
Thread1.start();
Thread2.start();
Thread3.start();
}
5.守护线程
守护线程的唯一用途就是为其他线程提供服务，例如计时器线程和JVM的垃圾回收器（GC）。当所有非守护线程结束的时候，守护线程也会伴随着自动结束。
Thread daemonThread = new Thread();
//把daemonThread设置为守护线程
daemonThread.setDaemon(true);
//查看该线程是否为守护线程
daemonThread.isDaemon();
6.线程的优先级
? 每一个线程都有一个优先级。每当线程调用都会优先选择优先级高的线程先运行，但是线程的优先级是高度依赖于系统。
? 默认情况下线程优先级为5，优先级可以设置为1-10级， 最小为1最大为10。可通过setPriority()设置线程优先级。
Thread thread = new Thread();
thread.setPriority(5);//设置优先级为5
7.Synchronized锁
? Synchronized关键字 相当于给该方法或者类加上锁，让同一时间内只能有一个线程使用，只有当这个线程使用完释放锁后，下个线程才能获取。
public class TextSyn{
int obj;
// 对统一对象加锁
public synchronized void run1(){
Thread.sleep(1000);
//实现对应方法
}
public synchronized void run2(){
//实现对应方法
}
//对该类加锁
public static synchronized void runStatic(){
//实现对应方法
}
public void add(){
//同步块 会获取obj的锁，专门用于obj这个对象。
synchronized (obj){
obj++;
}
}
}
public static void main(String[] args) {
TextSyn textSyn1 = new TextSyn();
TextSyn textSyn2 = new TextSyn();
//会先执行run1,再执行run2;
new Thread(()->{textSyn1.run1()}).start();
new Thread(()->{textSyn1.run2()}).start();
//会先执行run2,再执行run1;
new Thread(()->{textSyn1.run1()}).start();
new Thread(()->{textSyn2.run2()}).start();
//先执行runStatic 后执行run1,是因为run1睡眠了1秒钟，而不是run1先拿到锁
//run1的锁是对应这个textSyn对象的，而runStatic是静态方法，对应的是TextSyn这个类的锁
//所以他们不属于同一个锁，就不相互影响。
new Thread(()->{textSyn1.run1()}).start();
new Thread(()->{textSyn1.runStatic()}).start();
}
java.lang.Object
void wait();
//将该线程进入等待状态，直到得到通知。该方法只能在同一个同步方法或同步块中调用。
//如果当前线程不是对象锁的拥有者，则会抛出 IllegalMonitorStateException异常。
void notify();
//唤醒该对象上调用了wait()方法的**某一个**线程。该方法只能在同一个同步方法或同步块中调用。
//如果当前线程不是对象锁的拥有者，则会抛出 IllegalMonitorStateException异常。
void notifyAll();
//唤醒该对象上调用了wait()方法的所有线程。该方法只能在同一个同步方法或同步块中调用。
//如果当前线程不是对象锁的拥有者，则会抛出 IllegalMonitorStateException异常。
8.Lock锁（JUC)
Lock是（java.util.concurrent）下的接口，实现类有
ReentrantLock,
ReentrantReadWriteLock.ReadLock,
ReentrantReadWriteLock.WriteLock
Lock锁的应用
class TextLock{
private ReentrantLock lock = new ReentrantLock();
public void text(){
//加锁
lock.lock();
try{
//业务代码
}catch(Exception e){
e.printStackTrace();
}finally{
lock.unlock();//最后一定要解锁，不然会出现死锁问题。
}
}
}
java.util.concurrent.locks.Condition
void await();//将该线程放在这个条件的等待集中
void singalAll();//唤醒该条件等待集中所有线程
void singal();唤醒该条件等待集中某一个线程
//公平锁：十分公平：可以先来后到
new ReentrantLock(true)
//非公平锁（默认）：十分不公平：可以插队
new ReentrantLock(false)
9.Synchronized锁和Lock锁的区别
1、Synchronized 内置的Java关键字， Lock 是一个Java类 。
2、Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到锁。
3、Synchronized 会自动释放锁，Lock 必须要手动释放锁[lock.unlock()]，如果不释放锁，会造成死锁。
4、Synchronized 线程 1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去；
5、Synchronized 可重入锁，不可以中断的，非公平；Lock ，可重入锁，可以判断锁，默认非公平（可以自己设置）；
6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！