文章目录

相关概念
一、创建线程的两种方式
- 1.1 Thread类
- 1.2 Runnable接口
- 1.3 Thread和Runnable的区别
二、线程的五种状态
三、线程安全
- 3.1 线程安全
- 3.2 线程安全实例
四、线程同步
- 4.1 同步代码块
- 4.2 同步方法
- 4.3 Lock锁
- 4.4 synchronized 和 Lock 有什么区别？
总结

一、创建线程的两种方式

1.1 Thread类

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

自定义线程类：

//1.创建一个Thread类的子类
public class MyThread extends Thread{//在Thread类的族类中重写Thread类中的run方法，设置线程任务（开启线程要做什么）@Overridepublic void run(){for(int i=0; i<20; i++){System.out.println("run:"+i);}}
}

测试类

public class Demo01Thread {public static void main(String[] args) {//3.创建Thread类的子类对象实例MyThread mt = new MyThread();//4.调用Thread类中的方法start(),开启新的线程,执行run方法mt.start();for(int i=0; i<20; i++){System.out.println("main线程:"+i);}}
}

1.2 Runnable接口

采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。
步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

步骤一：

public class MyRunnable implements Runnable{ @Override public void run() { for (int i = 0; i < 20; i++) {     System.out.println(Thread.currentThread().getName()+" "+i); } }
}

步骤二三：

public class Demo { public static void main(String[] args) { //创建自定义类对象 线程任务对象 MyRunnable mr = new MyRunnable(); //创建线程对象 Thread t = new Thread(mr, "小强"); t.start(); for (int i = 0; i < 20; i++) { System.out.println("旺财 " + i); } }
}

1.3 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

二、线程的五种状态

线程状态	发生条件
New(新建)	线程刚被创建，但是并未启动。还没调用start方法
Runnable(可运行)	一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序来调度的。
Running(运行状态)	当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。
Blocked(锁阻塞)	①线程通过调用sleep方法进入睡眠状态；②线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；③线程试图得到一个锁，而该锁正被其他线程持有；④线程在等待某个触发条件；所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。
dead(死亡状态)	①run方法正常退出而自然死亡；②一个未捕获的异常终止了run方法而使线程猝死；为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法，如果是可运行或被阻塞，这个方法返回true；如果线程仍旧是new状态且不是可运行的，或者线程死亡了，则返回false。

三、线程安全

3.1 线程安全

什么是线程安全？
当多个线程访问某个类时，不管运行时环境采用何种调度方式或者这些线程将如何交替执行，并且在调用代码中不需要任何额外的同步或者协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

线程安全在三个方面的体现：
原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；
可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；
有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）。

3.2 线程安全实例

下面以一个实例来描述线程安全问题：
假设来模拟电影院的售票窗口，实现多个窗口同时卖票，总票数100张，窗口使用线程对象来模拟，票使用Runnable接口来模拟；

模拟票：

public class Ticket implements Runnable {private int ticket = 100;/** 执行卖票操作 */@Override public void run() {//每个窗口卖票的操作// 窗口 永远开启while (true) {if (ticket > 0) {//有票 可以卖，出票操作，使用sleep模拟一下出票时间try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto‐generated catch blocke.printStackTrace();//}//获取当前线程对象的名字String name = Thread.currentThread().getName();System.out.println(name + "正在卖:" + ticket--);}}}
}

测试类

public class Demo {public static void main(String[] args) {//创建线程任务对象Ticket ticket = new Ticket();//创建三个窗口对象Thread t1 = new Thread(ticket, "窗口1");Thread t2 = new Thread(ticket,"窗口2");Thread t3 = new Thread(ticket,"窗口3");//调用start方法，模拟同时卖票t1.start();t2.start();t3.start();}
}

来看运行结果：

程序出现两个问题：
1.相同的票号被卖了几次。
2.不存在的票，比如0或者-1票，是不存在的。

上面这种问题，几个窗口(线程)票数不同步，被称为线程不安全，那下面来说说线程同步。

四、线程同步

根据上面的案例：
窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

下面介绍三种方式完成同步操作。

4.1 同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。格式:

synchronized(同步锁){需要同步操作的代码
}

底层实现原理：synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。Java中每一个对象都可以作为锁，这是synchronized实现同步的基础。锁对象的作用是把同步代码块锁住,只让一个线程在同步代码块中执行。
测试类与上面一样，修改模拟买票部分代码演示：

public class RunnableImpl implements Runnable{//定义一个多线程功共享票源private int ticket = 100;//创建一个锁对象Object obj = new Object();//设置线程任务@Overridepublic void run(){//使用死循环，让卖票操作重复执行while(true){//同步代码块synchronized (obj){//先判断票是否存在if(ticket>0){//提高安全问题出现的概率，让程序睡眠try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}//票存在，卖票System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");ticket--;}}}}
}

4.2 同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。格式：

public synchronized void method(){可能会产生线程安全问题的代码
}

还是以卖票案例为基础，测试方法部分不变，代码演示：

public class Ticket implements Runnable {private int ticket = 100;/*** 执行卖票操作*/@Overridepublic void run() {//每个窗口卖票的操作 //窗口 永远开启while (true) {sellTicket();}}/*** 锁对象是谁调用这个方法就是谁* 隐含锁对象就是 this*/public synchronized void sellTicket() {if (ticket > 0) {//有票可以卖, 出票操作, 使用sleep模拟一下出票时间try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto‐generated catch blocke.printStackTrace();}//获取当前线程对象的名字String name = Thread.currentThread().getName();System.out.println(name+"正在卖"+ticket--);}}
}

4.3 Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

使用步骤：

    1.在成员位置创建一个ReentrantLock对象2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

还是以卖票案例为基础，加上Lock锁，代码演示：

 public class RunnableImpl implements Runnable{//定义一个多线程功共享票源private int ticket = 100;//1.在成员位置创建一个ReentrantLock对象Lock l = new ReentrantLock();//设置线程任务@Overridepublic void run(){//使用死循环，让卖票操作重复执行while(true){//2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁l.lock();//先判断票是否存在if(ticket>0){//提高安全问题出现的概率，让程序睡眠try {Thread.sleep(10);//票存在，卖票System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");ticket--;} catch (InterruptedException e) {e.printStackTrace();}finally {//3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁l.unlock();//无论程序是否异常,都会把锁释放}}}}
}

4.4 synchronized 和 Lock 有什么区别？

首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
synchronized会自动释放锁(a 线程执行完同步代码会释放锁；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）；
Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。

总结

有关多线程方面的知识就介绍找么多，大家可以了解一下。

JavaSE——多线程相关推荐

[javaSE] 多线程（守护线程）
我们一般使用多线程,都是while的死循环,想要结束线程,只需退出死循环即可当线程中调用了sleep()方法或者wait()方法,当前的线程就会进入冻结状态,这个线程就结束不了调用Thread对象 ...
JavaSE | 多线程
一.实现线程的方式一:继承java.lang.Thread类 1.步骤 (1)编写线程类,继承java.lang.Thread类 (2)重写public void run(){} 在run()的方法体 ...
JavaSE 多线程
多线程多任务多线程进程线程程序,进程与线程并发与并行实现线程(线程的创建) (1)Thread类 (2)Runnable接口 1.Runnable接口的实现 2一份资源,多个代理 (3) ...
22.11.20补卡 javaSE多线程学习笔记
自用并发编程多个任务同时执行并发原理: CPU分时间片交替执行, 宏观并行, 微观串行; 由OS调度进程: OS中并发的一个任务线程: 在一个进程中,并发的一个顺序执行流程每当执行新的进程 ...
[javaSE] 多线程（join方法）
多条线程并发执行,随机切换,调用join()方法,会使当前线程所在的线程(一般主线程)冻结,直到当前线程结束,所在的线程才恢复继续执行 class JoinTestDemo implements Ru ...
视频专辑：JAVA语言入门视频教程
为什么80%的码农都做不了架构师?>>> 专辑:JAVA语言入门视频教程简介:该视频专辑是java的入门教程,适合初学者学习java,讲的也非常容易懂,希望能给想学习java ...
android 精灵图的使用方法,css sprites（精灵图）如何使用？
CSS Sprites是一种性能优化技术,一种网页图片应用处理方式:将多个图像组合成单个图像文件以在网站上使用的方法,以提高性能:也被称为css 精灵图. 网页通常包含多个图像.这些包括图标,按钮,徽 ...
互联网java工程师面试突击第三季知识点总结
目录 Java集合包 01. HashMap的底层数据结构是什么? 02. JDK1.8中对hash算法和寻址算法是如何优化的? 03.HashMap是如何解决hash碰撞问题的? 04.说说Hash ...
JavsSE内容全链接
JavsSE内容全链接 JavaSE语言概述 JavaSE基本语法上 JavaSE基本语法下 JavaSE数组 JavaSE面向对象编程上 JavaSE面向对象编程中 JavaSE面向对象编程下 Ja ...
【备战校招】阅文集团Java实习生笔试题
好久没学习后端知识了(大概4天吧.)最近状态比较低迷,除了开始沉迷游戏,还要复习准备本专业的考试.通过一段时间的努力,我突然才意识太高估自己的自控能力了,原来坚持是一件那么难的事情,然而,我没有退路了 ...

JavaSE——多线程