java是多线程_Java之多线程（一）

一，前言

​今天总结一些关于线程方面的知识，说到线程可谓是无人不知，毕竟这东西不管是在工作开发中，还是实际生活中都时时存在着。关于线程方面的内容非常多，从简单的单线程，多线程，线程安全以及到高并发等等，当然也包括信息通信。

​当然这次从线程的基本开始，后面也会慢慢的补充线程的高级使用，这也算是让自己再复习一次了(哈哈)。

​以下内容包括：

二，线程介绍

三，线程的创建

四，线程安全

五，线程池

二，线程介绍

​先来介绍几个关于线程方面的概念。

2.1，并行与并发

并发：指两个或多个事件在同一个时间段内发生。

并行：指两个或多个事件在同一时刻发生(同时发生)。

​在我们的实际操作系统中，会存在多个应用程序，那么在单CPU的情况下如何同时执行多个程序。从宏观上观察多个程序同时运行，但是从微观角度看其实这是CPU在多个程序之间进行高速切换，只是切换的速度是非常的快，因此看上去像是在一起执行。

​反过来说，在多CPU的情况同样是在多程序之间来回切换，但是这种情况下不再是一个CPU在处理。就像工人一样，人越多干活就越快，也因此大大提高了计算机的运行速度。

2.2 ，线程与进程

进程：当应用程序进入到内存中时，每个应用程序都有其独立的内存空间。进程就是程序在内存中的执行过程，是程序运行的基本单位。

线程：而线程是进程的执行单元，进程的执行是需要线程依靠的，可以是单线程，也可以是多线程。

一个程序运行后至少有一个进程，一个进程中可以包含多个线程 。

​ 我们可以再电脑底部任务栏，右键----->打开任务管理器,可以查看当前任务的进程：

线程调度:

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

三，线程的创建

​创建线程有两种方式：

继承java.lang.Thread类，重写run方法实现线程创建。

实现java.lang.Runnable接口，实例化其实现类对象创建线程。

3.1，Thread

​先来看看API文档的说明：

Thread是一个类，但同时也实现了Runnable接口。

接着使用Thread创建线程。

public class ThreadMain {

public static void main(String[] args) {

// 1，实例化ThreadMode对象

ThreadMode thread = new ThreadMode();

// 2，调用start()方法启动线程

thread.start();

}

}

/**

* 继承Thread类

*/

class ThreadMode extends Thread {

// 1，重写父类的run方法。

@Override

public void run() {

System.out.println("使用Thread创建线程！");

}

}

3.2，构造方法

​public Thread()：分配新的 Thread 对象。

​public Thread(Runnable target)：分配一个带有指定目标的新线程。

​public Thread(String name)：分配一个带有名字的新线程。

​public Thread(Runnable target, String name)：分配一个带有指定目标的新线程，并指定线程的名字。

3.3，Runnable

​java.lang.Runnable：Runnable 接口该由那些打算通过某一线程其实例的类来实现。类必须定义一个称为run的无参方法。

实现步骤：

​1，创建一个Runnable接口的实现类。

​2，在实现类中重写Runnable接口中的run方法，设置线程的任务。

​3，创建一个Runnable实现类的对象。

​4，创建Thread类对象，构造方法中传递Runnable接口的实现类对象。

​5，调用Thread类中start方法，开启线程执行run方法。

public class ThreadInterface implements Runnable{

@Override

public void run() {

System.out.println("使用Runnable创建线程！");

}

}

// 在main方法中，创建实现类对象并开启线程

ThreadInterface thread = new ThreadInterface();

new Thread(thread,"runnable").start();

​说到这里Thread类和Runnable接口都可以创建新的线程，那么它们之间又有什么区别呢？

​使用Runnable接口的好处：

避免了单继承的局限性一个类只能继承一个父类，如果创建线程选择继承Thread类，那么就不能再继承别的父类。而采用实现Runnable接口，则还可以再继承，且再实现别的接口。

增强了程序的扩展性，降低了程序的耦合性(解耦)实现Runnable接口的方式，把设置线程任务和开启线程的任务进行了分离。

3.4，匿名内部类方式创建线程

​作用：

​1，简化代码

​2，把子类继承父类，重写父类的方法，创建子类对象一步合成。

​3，把实现类接口，重写接口中的方法，创建实现类对象一步合成。

​格式：

​new 父类/接口(){}

​Thread

new Thread(){

@Override

public void run() {

super.run();

}

}.start();

​使用lambda表达式写法(JDK8特性，后面会分享该特性)：

new Thread(() -> System.out.println("Thread匿名内部类")).start();

​Runnable

Runnable runnable = new Runnable() {

@Override

public void run() {

System.out.println("Runnable匿名内部类");

}

};

// 开启线程

new Thread(runnable).start();

​使用lambda表达式：

Runnable runnable = () -> System.out.println("Runnable匿名内部类");

// 开启线程的第一种方式

new Thread(runnable).start();

四，线程安全

​线程安全通常有3种解决方式：

​1，同步代码块

​2，同步方法

​3，锁机制(lock)

​我们以卖车票为案例，用三种方式去解决车票的重复售卖，超卖情况。

4.1，同步代码块

​格式:

​ synchronized(锁对象){

​ 可能会出现线程安全问题的代码(访问了共享数据的代码)

​ }

​注意:

1.通过代码块中的锁对象,可以使用任意的对象。

2.但是必须保证多个线程使用的锁对象是同一个。

3.锁对象作用: 把同步代码块锁住,只让一个线程在同步代码块中执行。

public class RunnableImpl implements Runnable{

//定义一个多个线程共享的票源

private int ticket = 100;

//创建一个锁对象

Object obj = new Object();

//设置线程任务:卖票

@Override

public void run() {

//使用死循环,让卖票操作重复执行

while(true){

//同步代码块

synchronized (obj){

//先判断票是否存在

if(ticket>0){

//提高安全问题出现的概率,让程序睡眠

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

//票存在,卖票 ticket--

System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");

ticket--;

}

}

}

}

}

​在main方法中调用线程，并模拟三个窗口同时售票。

public class Demo01Ticket {

public static void main(String[] args) {

//创建Runnable接口的实现类对象

RunnableImpl run = new RunnableImpl();

//创建Thread类对象,构造方法中传递Runnable接口的实现类对象

Thread t0 = new Thread(run);

Thread t1 = new Thread(run);

Thread t2 = new Thread(run);

//调用start方法开启多线程

t0.start();

t1.start();

t2.start();

}

}

4.2，同步方法

​使用步骤:

​ 1.把访问了共享数据的代码抽取出来,放到一个方法中

​ 2.在方法上添加synchronized修饰符

​格式:定义方法的格式

​修饰符 synchronized 返回值类型 方法名(参数列表){

可能会出现线程安全问题的代码(访问了共享数据的代码)

​}

public class RunnableImpl implements Runnable{

//定义一个多个线程共享的票源

private static int ticket = 100;

//设置线程任务:卖票

@Override

public void run() {

System.out.println("this:"+this);

//使用死循环,让卖票操作重复执行

while(true){

payTicketStatic();

}

}

/*

静态的同步方法

不能是this

this是创建对象之后产生的,静态方法优先于对象

静态方法的锁对象是本类的class属性-->class文件对象(反射)

*/

public static /*synchronized*/ void payTicketStatic(){

synchronized (RunnableImpl.class){

//先判断票是否存在

if(ticket>0){

//提高安全问题出现的概率,让程序睡眠

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

//票存在,卖票 ticket--

System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");

ticket--;

}

}

}

/*

定义一个同步方法

同步方法也会把方法内部的代码锁住

只让一个线程执行

同步方法的锁对象是谁?

就是实现类对象 new RunnableImpl()

也是就是this

*/

public /*synchronized*/ void payTicket(){

synchronized (this){

//先判断票是否存在

if(ticket>0){

//提高安全问题出现的概率,让程序睡眠

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

//票存在,卖票 ticket--

System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");

ticket--;

}

}

}

}

​在main函数中调用该线程，其代码与上述一样。

4.3，同步锁(Lock)

​java.util.concurrent.locks.Lock接口

Lock 实现提供了比使用 synchronized方法和语句可获得的更广泛的锁定操作。

Lock接口中的方法:

​ void lock()获取锁。

​ void unlock() 释放锁。

​使用步骤:

​ 1.在成员位置创建一个ReentrantLock对象。

​ 2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁。

​ 3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁。

​请看如下API说明：

​

public class RunnableImpl implements Runnable{

//定义一个多个线程共享的票源

private int ticket = 100;

//1.在成员位置创建一个ReentrantLock对象

Lock l = new ReentrantLock();

//设置线程任务:卖票

@Override

public void run() {

//使用死循环,让卖票操作重复执行

while(true){

//2.在可能会出现安全问题的代码前调用Lock接口中的方法lock获取锁

l.lock();

//先判断票是否存在

if(ticket>0){

try {

//票存在,卖票 ticket--

System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");

ticket--;

} catch (InterruptedException e) {

e.printStackTrace();

}finally {

//3.在可能会出现安全问题的代码后调用Lock接口中的方法unlock释放锁

l.unlock();//无论程序是否异常,都会把锁释放

}

}

}

}

}

五，线程池

​如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程是需要时间的。

​在JDK5之前，对于线程池的使用是需要程序员用集合来自己进行创建。在JDK5之后就不再需要手动去创建，JDK已经帮我们封装好了。

5.1，线程池概念

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

​ 用一张简单的图来理解下线程池工作的原理。

​

合理利用线程池能够带来三个好处：

降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，可能最后死机)。

5.2，使用方式

​Java里面线程池的顶级接口是java.util.concurrent.Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

Executors类中有个创建线程池的方法如下：

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

public Future> submit(Runnable task):获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用。

使用线程池中线程对象的步骤：

创建线程池对象。

创建Runnable接口子类对象。

提交Runnable接口子类对象。

关闭线程池(一般不做,因为再次使用的时候线程池中就没有线程了)。

public class MyRunnable implements Runnable {

@Override

public void run() {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("线程： " + Thread.currentThread().getName());

}

}

public class ThreadPoolDemo {

public static void main(String[] args) {

// 创建线程池对象

ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象

// 创建Runnable实例对象

MyRunnable r = new MyRunnable();

// 从线程池中获取线程对象

service.submit(r);

// 再获取多个线程

service.submit(r);

service.submit(r);

// 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。而且将使用完的线程又归还到了线程池中

}

}

六，sleep()与wait()

​1，所属分类不同，sleep属于Thread类中，而wait属于Object类中。

​2，锁控制不同，sleep不会释放锁，而wait会释放锁且不会影响其他线程进入同步代码块或同步方法中。也就是说sleep会占用资源，wait不会占用资源。

​3，sleep可以在任意地方使用，而wait需在同步代码块或者同步方法中使用。

七，volatile与synchronized

​1，volatile性能比synchronized要好，因为volatile是线程同步的轻量级实现，但是在jdk1.5之后性能有所提高了。

​2，volatile只能修饰变量，synchronized可以修饰方法以及代码块。

​3，多线程访问volatile不会发生阻塞，synchronized会出现阻塞。

​4，volatile能保证数据的可见性，但不能保证原子性。synchronized可以保证原子性。

​5，volatile解决变量在多线程之间的可见性。synchronized解决的是多线程之间访问资源的同步性。

​6，volatile防止指令重排。

八，总结

​似乎觉得本人的每一篇博客的篇幅都好长，可能是因为都是一些很基础的知识点吧，所以就会涉及到很多方方面面，写着写着就很多了。不过这样记下来时间久了还可以再回来看看，多少也算有点印象(哈哈)。

​如果你阅读到此，很感谢您的耐心。以上总结的内容，如有不适之处，欢迎留言指正。

感谢阅读！