在java中对于多线程的实现一定要有一个多线程的主类，多线程主类的实现是要有一定要求的

• 继承Thread父类

在java.lang包中，子类继承Thread类之后需要覆写Thread类中的run方法，
run方法就是线程的主方法，特别需要注意的是所有的多线程的执行一定是并发完成的，即每个时间段上会有多个线程交替执行，所以为了达到这样的目的绝对不能直接调用run方法，而是应该调用Thread只能的start方法启动多线程。

思考为什么启动多线程不使用run而非要使用start方法？？

由于线程的启动需要牵扯到操作系统的资源分配问题，所以具体的线程启动应该要根据不同的操作系统有不同的实现，而JVM相当于根据系统中定义的start0()方法来根据不同的操作系统进行该方法的实现。
由于Thread类的start方法会调用start0()方法，所以只有start()方法才能进行操作系统资源的分配

• 实现Runnable接口或者是 Callable接口

继承Thread类会产生单继承的局限操作，所以最好的方法是用接口，观察Runnable的操作接口的定义结构
在java.lang中，是个函数式接口，只有一个run方法，然而如果要启动多线程只能使用start方法，实现接口没有start()方法，可以利用Thread的构造方法
public Thread(Runnable target)能够接受Runnable对象

---

MyThread myThread1=new MyThread("线程1");
MyThread myThread2=new MyThread("线程2");
MyThread myThread3=new MyThread("线程3");
new Thread(myThread1).start();
new Thread(myThread2).start();
new Thread(myThread3).start();

---

很多时候为了方便可能直接使用匿名内部类或者lamada表达式

匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i <10 ; i++) {
System.out.println(i);
}
}
}).start();

Lamda
new Thread(()->{
for (int i = 0; i <10 ; i++) {
System.out.println(i);
}
}).start();

只要给出的是函数式接口都可以使用Lamda表达式

多线程两种实现方式的区别

首先观察Thread类的定义结构：
public class Thread extends Onbject implements Runnable
可以发现Thread实现了Runnable接口。
Runnable接口实现的多线程要比Thread类实现的多线程要更方便的表示出数据共享的操作（卖票）
MyThread myThread=new MyThread();

new Thread(myThread).start();
new Thread(myThread).start();
new Thread(myThread).start();
操作的同一个票数据，实现了数据共享

Callable借口

从jdk1.5之后多了一个Callable接口，比Runnable接口强大之处在于可以返回执行结果
这个接口在java.util.concurrent包中，结构如下
public interface Callable<V>{
public V call() throws Exection
}
这个泛型表示的是返回值类型，call()方法就是run()方法
问题是Thread类中没有接受Callable对象的构造方法，为了启动线程需要观察继承结构

image.png

Callable<String> cal=new MyThread();
FutureTask<String> task =new FutureTask<String>(cal);//取得执行结果
Thread thread=new Thread(task);
thread.start();
System.out.println(task.get());

多线程的常用操作方法

• 线程的命名和取得

多线程的运行状态不是固定的，要想确定线程的执行唯一的区别在于线程的名称上。在起名的时候避免重名，或者避免修改名称。
实现线程名称的操作

• 构造方法：public Thread(Runnable target,String name
• 设置名字：public final void setName(String name)
• 取得名字：public String getName()

既然线程的执行本身是不确定的状态，所以如果要取得线程名字的话。那么唯一能做的就是取得当前的线程上的名字，所以在Thread类提供了这个方法：public static Thread currentThread()
如果在设置线程对象时没有设置名字，会采取默认的名字
直接调用run()方法，会自动取名为main

• 线程休眠

如果要想让某些线程延缓执行，可以使用休眠的方式来处理，休眠操作如下：

• 休眠方法：public static void sleep(long millis) throw InterruptedExection
  这个异常表示，如果休眠的时间没到就停止休眠了，那么就会产生中断异常，线程被中断一定是被其他的线程中断

• 线程优先级

从理论上来讲，优先级越高的线程越有可能先执行，在Thread类中有一下的优先级方法

• 设置优先级：public final void setPriority(int newPriority);
• 取得优先级：public final int getPriority

对于优先级一共定义有三种

• 最高优先级：public static final int MAX_PRIORITY 10
• 中等优先级：public static final int NORM_PRIORITY 5
• 最低优先级：public static final int MIN_PRIORITY 1
  主线程是中等优先级

线程的同步与死锁

同步问题的引出

如果要想进行同步操作，多个线程访问同一个资源
正常代码：
public class MyThread implements Runnable {
private int tickets=5;
@Override
public void run() {
for (int i = 0; i <10 ; i++) {
if(this.tickets>0){
System.out.println(Thread.currentThread().getName()+",ticket="+this.tickets--);
}

    }
}

}

MyThread mt=new MyThread();
Thread t1=new Thread(mt,"票贩子A");
Thread t2=new Thread(mt,"票贩子B");
Thread t3=new Thread(mt,"票贩子C");
t1.start();
t2.start();
t3.start();
执行和结果没有问题
票贩子A,ticket=5
票贩子B,ticket=3
票贩子C,ticket=4
票贩子B,ticket=1
票贩子A,ticket=2

如果线程休眠，会出现问题
执行结果变为
票贩子A,ticket=5
票贩子C,ticket=3
票贩子B,ticket=4
票贩子A,ticket=2
票贩子B,ticket=1
票贩子C,ticket=0
票贩子A,ticket=-1

解决不同步的问题，实现同步操作
实现锁的概念使用同步代码块或同步方法

• 同步代码块
  使用synchronized关键字定义的就是同步代码块，但是在进行同步的时候需要设置有一个同步对象，往往使用this
  for (int i = 0; i <10 ; i++) {
  synchronized (this){
  if(this.tickets>0){
  try {
  Thread.sleep(1000);
  System.out.println(Thread.currentThread().getName()+",ticket="+this.tickets--);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
  

加入同步代码块之后程序执行的速度变慢了。而且不像没有同步的时候那样多个线程一起进入到方法体中，异步的执行速度快于同步，是非线程不安全

• 同步方法
  private int tickets = 5;

  @Override
  public void run() {
  this.sale();
  }

  public synchronized void sale() {
  for (int i = 0; i < 10; i++) {
  if (this.tickets > 0) {
  try {
  Thread.sleep(1000);
  System.out.println(Thread.currentThread().getName() + ",ticket=" + this.tickets--);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
  
    }
  

  }

死锁（等待太多出现的问题）

死锁是一种不确定的状态，对于死锁的操作，出现的越少越好
死锁代码演示
import java.util.concurrent.ExecutionException;
class QiangDao {
public synchronized void say(YouQianRen yqr) {
System.out.println("强盗说：给我3000万美金");
yqr.get();
}
public synchronized void get() {
System.out.println("强盗得到了钱");
}
}

class YouQianRen {
public synchronized void say(QiangDao qd) {
System.out.println("有钱人说：先放了我儿子在给你钱");
qd.get();
}
public synchronized void get() {
System.out.println("孩纸被救回");
}
}

public class Main implements Runnable {
private QiangDao qd = new QiangDao();
private YouQianRen yqr = new YouQianRen();
public Main() {
new Thread(this).start();
yqr.say(qd);
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
new Main();
}
@Override
public void run() {
qd.say(yqr);
}
}
面试题：请问多个线程访问统一资源时会产生什么问题，以及会产生什么费附加问题。

• 多个线程访问统一资源必须考虑同步，可以使用synchronized 定义同步代码块或者同步方法。
• 程序中如果出现过多的同步那么将会产生死锁