前言

Java是支持多线程的编程语言，所谓多线程就是程序能够同时完成多种操作。
计算机完成可以多种操作同时进行，这种思想在Java中被称为并发，而将并发完成的多种操作被称为线程。

---

一、线程的创建

在Java中线程的创建一般分为两种方式：

• 继承Thread类创建
• 实现Runnable接口创建

---

1、继承Thread类

Java中的Thread类是java.lang包中的核心类，它代表一个线程。它主要用于创建新线程并在其中执行自定义任务。

Thread类的主要特点包括：

1. 继承性：Thread类是java.lang.Object的子类，因此可以继承Object类的属性和方法。
2. 抽象性：Thread类是一个抽象类，这意味着它不能直接实例化。为了使用Thread类，我们需要创建一个Thread的子类，并重写其run()方法。
3. 线程安全性：Thread类是线程安全的，这意味着多个线程可以同时调用Thread类的方法，而不会导致数据不一致或其他并发问题。
4. 常用方法：Thread类有许多有用的方法，包括start()（启动线程）、run()（执行线程）、sleep()（使线程休眠）、interrupt()（中断线程）等。

---

继承Thread类创建一个新的线程语法：

public class MyThread extends Thread {  @Override  public void run() {  // 在这里编写线程需要执行的代码  System.out.println("My thread is running.");  }  
}

完成线程真正功能的代码放置在run方法中执行，该线程在执行完run方法中的代码后就会停止。

示例：

public class demo_1 {public static void main(String[] args) {/*实现方式：1自定义一个类继承Thread、或者构建Thread对象，重写run方法重写run方法启动线程*/MyThread t1=new MyThread();MyThread t2=new MyThread();// 为线程指定名字t1.setName("线程一");  t2.setName("线程二");t1.start(); // 开启线程t2.start(); // 开启线程}
}
class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName()+ "芜湖");}}
}

---

2、实现Runnable接口

上一种方式创建线程的方式，是通过继承Thread类的方式创建的，但是Java是只支持单继承的语言，所以如果通过上一个方式创建线程的话，拓展性不太好。因此就可以使用实现接口的方式来创建线程。

实现过程：

1. 自定义一个类实现Runnable接口
2. 重写run方法，
3. 创建自己类的对象，
4. 创建Thread对象开启线程

示例：

package text_1;public class demo_2 {public static void main(String[] args) {/**   第二种实现方式：*   自定义一个类实现Runnable接口*   重写run方法，*   创建自己类的对象，*   创建Thread对象开启线程** */MyRun mr=new MyRun();Thread t1=new Thread(mr);Thread t2=new Thread(mr);t1.setName("芜湖");t2.setName("呀呼");t1.start();t2.start();}
}
class MyRun implements Runnable{@Overridepublic void run() {Thread thread = Thread.currentThread(); // 获取当前线程的对象for (int i = 0; i < 10; i++) {System.out.println(thread.getName()+ "爱坤");}}
}

只所以能通过这中方式创建线程，是因为Thread类就是Runnable接口的实现类。

且在Thread类中的构造方法中有Runnable的实例，使用这种构造方法就可以将Runnable实例与Thread实例相关联，也就是说，使用这种构造方法后，Thread类调用的run方法就是Runnable中的run方法。

---

二、线程的生命周期

---

三、操作线程的方法

操作线程的方法有很多，这些方法可以使得线程从某种状态过度到另一种状态。

---

1、线程的休眠

sleep方法

该方法使得当前线程在指定的时代内不会进入就绪状态。
该方法是被static修饰的，所以可以直接使用类名调用。

示例：

package text_2;public class demo_1 {public static void main(String[] args) {MyThread mt1 = new MyThread();mt1.start();}
}class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 10; i++) {try {// 以毫秒为单位Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("芜湖");}}
}

---

2、线程的加入

join方法
在Java多线程编程中，join方法是一个非常重要的概念。它用于确保主线程等待其他线程完成其任务后再继续执行。当一个线程调用另一个线程的join方法时，调用线程会阻塞，直到被调用线程结束执行。

join方法通常在创建线程时使用，以确保主线程不会在子线程完成前结束。这有助于防止数据竞争和其他并发问题。

示例：

package text_2;public class demo_1 {public static void main(String[] args) throws InterruptedException {MyThread mt1 = new MyThread();MyThread mt2 = new MyThread();mt1.setName("wuhu");mt2.setName("yahu");mt1.start();mt1.join();mt2.start();}
}class MyThread extends Thread{@Overridepublic void run() {for (int i = 0; i < 4; i++) {try {// 以毫秒为单位Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(getName());}}
}

---

3、线程的礼让

在Java中，线程礼让是指在线程A和线程B执行的时候，线程B由于某种原因需要先一步执行，那么可以对线程A执行yield方法，先让线程B执行一步。请注意，这里和join方法不一样，join方法是将CPU资源全都分出，直到线程B执行完，而yield只会让出一步。

---

4、线程的优先级

在Java中，线程的优先级是一个整数，范围从1（最低优先级）到10（最高优先级）。默认情况下，新创建的线程的优先级为5。线程优先级越小，线程越优先被执行；线程优先级越大，线程越后被执行。可以通过Thread类的setPriority(int)方法来设置线程的优先级。

请注意，如果优先级相同的线程同时存在，那么会按照提交顺序（也就是代码编写顺序）执行的方式。

package text_2;public class demo_2 {public static void main(String[] args) {/**   设置优先级   ：setPriority()*   获取优先级   : get*   守护线程     ：setDaemon(boolean)*               细节：守护线程会在所有非守护线程结束后结束* */
//        System.out.println(Thread.currentThread().getPriority());MyThread_2 mt1 = new MyThread_2();MyThread_2 mt2 = new MyThread_2();mt1.setName("芜湖");mt2.setName("呀呼");System.out.println(mt1.getPriority());  // 获取当前优先级mt1.setPriority(10);System.out.println(mt1.getPriority());  // 获取当前优先级//        MyThread_3 mt3 = new MyThread_3();
//        mt3.setName("run");
//        mt3.setDaemon(true);mt1.start();mt2.start();}
}class MyThread_2 extends Thread{@Overridepublic void run() {Thread thread = Thread.currentThread();for (int i = 0; i < 10; i++) {System.out.println(thread.getName()+"i");}}
}
class MyThread_3 extends Thread{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName()+""+i);}}
}

---

四、线程同步

Java线程同步是一个非常重要的概念，主要用于解决多线程并发控制问题。当多个线程同时操作一个可共享的资源变量时，可能会产生数据不准确和相互冲突的问题。为了解决这些问题，Java提供了多种同步机制，包括synchronized关键字、Lock接口和AtomicInteger类等。

其中，synchronized关键字是最基本的同步机制，可以用于方法或代码块的同步。当一个线程在执行一个synchronized方法时，其他试图访问该对象的线程将被阻塞，直到第一个线程执行完毕。这样可以确保同一时间只有一个线程可以访问共享资源，避免了数据不一致和程序异常的问题。

一般情况：窗口售票

package text_3;public class demo {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");t1.start();t2.start();t3.start();}
}class MyThread extends Thread {static int ticket = 0;@Overridepublic void run() {while (true) {// 同步线程：线程锁（锁对象） 需要注意的是锁对象一定是要唯一的try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}if (ticket < 100) {++ticket;System.out.println(getName() + "正在卖第" + ticket + "张票");} else {break;}}}
}

运行结果：

---

通过运行结果，我们可以看出没有加线程同步的情况，多个线程对同一资源的访问，因为系统cpu轮转的情况，某一线程可能已经售出了某张票，但是另一个线程也在售出这张票，所以导致了重复售出的情况。

线程同步机制

线程同步机制是Java多线程编程中的重要概念，主要用于解决多线程并发控制问题。线程同步机制可以让多个线程按照一定的顺序执行，避免出现数据不一致和相互冲突的问题。Java中实现线程同步的方式有多种，包括synchronized关键字、Lock接口、信号量Semaphore、倒计时门闩CountDownLatch、循环栅栏CyclicBarrier和闭包等。

其中，synchronized关键字是最基本的线程同步机制之一，可以用于方法或代码块的同步。当一个线程在执行一个synchronized方法时，其他试图访问该对象的线程将被阻塞，直到第一个线程执行完毕。这样可以确保同一时间只有一个线程可以访问共享资源，避免了数据不一致和程序异常的问题。

需要注意的是，使用synchronized块进行同步线程时，同步代码块的对象一定需要是唯一的。

同步代码块改进

package text_3;public class demo {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");t1.start();t2.start();t3.start();}
}class MyThread extends Thread {static int ticket = 0;@Overridepublic void run() {while (true) {// 同步线程：线程锁（锁对象） 需要注意的是锁对象一定是要唯一的synchronized (MyThread.class) {try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}if (ticket < 100) {++ticket;System.out.println(getName() + "正在卖第" + ticket + "张票");} else {break;}}}}
}

运行结果： 杜绝了重复票的情况

---

End

本文如有错误，望指正。