Thread 线程同步、线程状态

r囧r小猫 2022-03-02 09:16 434阅读 0赞

# 线程概念 #

线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

## 一、多线程介绍 ##

**1.1创建线程类**  
Java中通过继承Thread类来创建并启动多线程的步骤如下：  
1.定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。  
2. 创建Thread子类的实例，即创建了线程对象  
3. 调用线程对象的start()方法来启动该线程  
测试类：  
public class ThreadIdea \{  
public static void main(String\[\] args) \{  
subThread th=new subThread();  
th.start();  
for (int i = 0; i < 200; i++) \{  
System.out.println(Thread.currentThread().getName()+" 主线程被执行"+i+“次”);  
\}  
\}  
\}  
自定义线程类：  
public class subThread extends Thread\{  
@Override  
public void run() \{//重写run方法  
for (int i = 0; i < 200; i++) \{  
System.out.println(Thread.currentThread().getName()+" 子线程被执行"+i+“次”);  
\}  
\}  
\}

## 二、多线程的原理 ##

**2.1多线程的原理**  
代码同上  
**2.2Thread类**  
操作过程中用到了*java.lang.Thread*类  
1.构造方法：  
public Thread():分配一个新的线程对象。  
public Thread(String name):分配一个指定名字的新的线程对象。  
public Thread(Runnable target):分配一个带有指定目标新的线程对象。  
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。  
2常用方法：  
public String getName():获取当前线程名称。  
public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。  
public void run():此线程要执行的任务在此处定义代码。  
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。  
public static Thread currentThread():返回对当前正在执行的线程对象的引用。  
翻阅API后得知创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式，方式一我们上一天已经完成，接下来讲解方式二实现的方式。  
**2.3 实现接口方式**  
采用*java.lang.Runnable*也是非常常见的一种，我们只需要重写run方法即可。  
步骤如下：  
1.定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。  
2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。  
3.调用线程对象的start()方法来启动线程。代码如下：  
测试类代码：  
public class test \{  
public static void main(String\[\] args) \{  
runnable runa=new runnable();  
Thread th=new Thread(runa);  
th.start();  
for (int i = 0; i < 1000; i++) \{  
System.out.println(Thread.currentThread().getName()+" 主线程被调用");  
\}  
\}  
\}  
Runnable接口代码：  
public class runnable implements Runnable\{  
@Override  
public void run() \{  
for (int i = 0; i < 1000; i++) \{  
System.out.println(Thread.currentThread().getName()+" 子线程被调用"+i);  
\}  
\}  
\}  
通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。  
在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。//代码中没体现构造Thread这一点  
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。  
**Thread和Runnable的区别**  
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。  
**总结：**  
**实现Runnable接口比继承Thread类所具有的优势：**  
1.适合多个相同的程序代码的线程去共享同一个资源。  
2.可以避免java中的单继承的局限性。  
3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。  
4.线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。  
**2.4 匿名内部类方式**  
使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：  
public class anonymousInsideClass \{  
public static void main(String\[\] args) \{  
new Thread(new runnable()\{  
@Override  
public void run() \{  
System.out.println(“使用匿名内部类线程”);  
\}  
\}).start();  
//相当于  
Thread th= new Thread();  
runnable runmethond=new runnable()\{  
@Override  
public void run() \{  
System.out.println(“使用匿名内部类线程”);  
\}  
\};  
new Thread(runmethond).start();  
\}  
\}

## 三、线程安全 ##

**3.1 线程安全**  
**3.2 线程同步**  
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。  
为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。那么怎么去使用呢？有三种方式完成同步操作：  
同步代码块。同步方法。锁机制。  
**3.3 同步代码块**  
同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。  
格式:  
synchronized(同步锁)\{  
需要同步操作的代码  
\}  
**同步锁:**  
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.  
锁对象 可以是任意类型。  
多个线程对象 要使用同一把锁。  
**同步方法**  
同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。  
**3.5 Lock锁**  
java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。  
Lock锁也称同步锁，加锁与释放锁方法化了，如下：  
public void lock():加同步锁。  
public void unlock():释放同步锁。

# 四、线程的状态 #

NEW(新建)  
线程刚被创建，但是并未启动。还没调用start方法。Runnable(可运行)线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。  
Blocked(锁阻塞)  
当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。  
Waiting(无限等待)  
一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。  
Timed Waiting(计时等待)  
同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。  
Teminated(被终止)  
因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。