Java进阶总结——线程

亦凉 2022-05-16 11:20 247阅读 0赞

**Java进阶总结——线程**

# 1.进程 #

> /\*\*
> 
>  \* java中启动进程的两种方式
> 
>  \* 1.RunTime，运行时类
> 
>  \* 2.ProcessBuilder类
> 
>  \* \*/

package day24.process;

import java.io.IOException;

public class ProcessDemo \{

public static void main(String\[\] args) throws IOException \{

/\*//1通过运行时类

Runtime time=Runtime.getRuntime();

//执行要打开的进程

time.exec("notepad");

time.exec("D:\\\\TSBrowserDownloads\\\\cmder\\\\Cmder.exe");

\*/

//2通过进程生成器启动进程

ProcessBuilder builder=new ProcessBuilder("notepad");

//启动进程

builder.start();

运行结果：

启动应用程序！

# 2.线程的实现 #

## 2.1继承Thread ##

>  /\*\*
> 
>  \* ThreadDemo继承了Thread
> 
>  \* 你什么该类就是一个线程类
> 
>  \* 必须在子类中重写run方法
> 
>  \* run方法是线程体
> 
>  \*  \* \*/

package day24.thread;

public class ThreadDemo extends Thread\{

@Override

public void run() \{

// 线程体

try \{

Thread.sleep(1000);//休眠1s

\} catch (InterruptedException e) \{

// TODO 自动生成的 catch 块

e.printStackTrace();

//获取线程名称

System.out.println(Thread.currentThread().getName());

public static void method() \{

//获取当前线程

System.out.println(Thread.currentThread().getName());

public static void main(String\[\] args) \{

// 1.获取当前线程

Thread th=Thread.currentThread();

//2.查看当前线程

System.out.println("名称："+th.getName());//名称

System.out.println("状态："+th.getState());//状态

System.out.println("ID："+th.getId());//ID

System.out.println("优先级："+th.getPriority());//优先级

method();

//3.创建一个子线程，启动了一个线程，其实做了一个异步操作

ThreadDemo th1=new ThreadDemo();

//给线程命名

th1.setName("尊");

//启动线程  不能直接调用run方法，必须通过start来调用

th1.start();

System.out.println("执行完毕！");

输出结果：

![70][]

## 2.2实现Runnable接口 ##

> /\*\*
> 
>  \* ThreadDemo1实现Runnable这个接口
> 
>  \* ThreadDemo1不是线程类
> 
>  \* \*/

package day24.thread;

public class ThreadDemo1 implements Runnable\{

@Override

public void run() \{

// 线程体

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

public static void main(String\[\] args) \{

//创建一个ThreadDemo1的实例

ThreadDemo1 demo=new ThreadDemo1();

//创建一个线程对象，执行demo对象

Thread th=new Thread(demo,"qq");

//启动线程

th.start();

//再次启动一个线程

Thread th1=new Thread(demo,"ww");

th1.start();

![70 1][]

# 3.线程的方法 #

## 3.1基本方法 ##

### 3.1.1线程优先级 ###

package day25.thread;

public class ThreadDemo extends Thread\{

@Override

public void run() \{

for (int i = 0; i < 120; i++) \{

System.out.println(Thread.currentThread().getName()+"\\t优先级："+Thread.currentThread().getPriority());

public static void main(String\[\] args) \{

//初始三个线程

ThreadDemo demo=new ThreadDemo();

ThreadDemo demo1=new ThreadDemo();

ThreadDemo demo2=new ThreadDemo();

//命名

demo.setName("A");

demo1.setName("B");

demo2.setName("C");

//设置优先级1-5  默认是5

demo.setPriority(MIN\_PRIORITY);

demo1.setPriority(MAX\_PRIORITY);

//启动

demo.start();

demo1.start();

demo2.start();

输出结果：

![70 2][]

### 3.1.2线程状态 ###

package day25.thread;

public class ThreadDemo2 extends Thread\{

@Override

public void run() \{

System.out.println("运行状态："+Thread.currentThread().getState()+"\\t激活："+Thread.currentThread().isAlive());

@SuppressWarnings("static-access")

public static void main(String\[\] args) throws InterruptedException \{

//初始化对象

ThreadDemo2 demo2=new ThreadDemo2();

System.out.println("创建状态："+demo2.getState()+"\\t\\t激活："+demo2.isAlive());

//启动线程

demo2.start();

System.out.println("启动状态："+demo2.getState()+"\\t激活："+demo2.isAlive());

demo2.sleep(2000);

System.out.println("完毕状态："+demo2.getState()+"\\t激活："+demo2.isAlive());

输出结果：

![70 3][]

### 3.1.3线程同步 ###

package day25.thread;

public class ThreadDemo1 extends Thread\{

@Override

public void run() \{

try \{

System.out.println("生日快乐");

Thread.sleep(2000);

\} catch (InterruptedException e) \{

// TODO 自动生成的 catch 块

e.printStackTrace();

System.out.println("七夕快乐！");

public static void main(String\[\] args) throws InterruptedException \{

// 初始化对象

ThreadDemo1 demo1=new ThreadDemo1();

//启动线程

demo1.start();

//合并线程，demo1和主线程合并

//demo1.join();//join在start之后使用

//主线程执行方法

for (int i = 0; i < 10; i++) \{

Thread.sleep(200);

if (i==3) \{

demo1.join();

System.out.println("i====="+i);

输出结果：

![70 4][]

### 3.1.4线程礼让 ###

package day25.thread;

public class ThreadDemo3 implements Runnable\{

@SuppressWarnings("static-access")

@Override

public void run() \{

for (int i = 0; i < 6; i++) \{

if (i==3) \{

//礼让线程

Thread.currentThread().yield();

System.out.println("礼让");

System.out.println("i=="+i+"  "+Thread.currentThread().getName());

public static void main(String\[\] args) \{

// 初始化对象

ThreadDemo3 demo3=new ThreadDemo3();

//创建线程

Thread th1=new Thread(demo3,"qq");

Thread th2=new Thread(demo3,"rr");

Thread th3=new Thread(demo3,"uu");

//启动线程

th1.start();

th2.start();

th3.start();

输出结果：

![70 5][]

### 3.1.5线程守护 ###

package day25.thread;

public class ThreadDaemonDemo extends Thread\{

@Override

public void run() \{

while (true) \{

try \{

Thread.sleep(500);

\} catch (InterruptedException e) \{

e.printStackTrace();

System.out.println("七夕节快乐");

public static void main(String\[\] args) throws InterruptedException \{

//创建对象

ThreadDaemonDemo demo=new ThreadDaemonDemo();

//把当前线程设为守护线程，需要在启动之前设置

demo.setDaemon(true);

//启动线程

demo.start();

System.out.println("不快乐！");

Thread.sleep(3000);

System.out.println("喝酒");

输出结果：

![70 6][]

## 3.2锁 ##

### 3.2.1synchronized修饰符 ###

> /\*\*
> 
>  \* synchronized修饰符
> 
>  \* 可以修饰方法，锁住的是当前对象this
> 
>  \* 可以修饰代码块
> 
>  \* 同步的意思
> 
>  \* \*/

package day25.thread;

public class AppleDemo implements Runnable \{

//苹果数量

private int count=50;

private static Object obj=new Object();

//修饰方法修饰的是this对象

public synchronized void method()\{

if (count>0) \{

System.out.println(Thread.currentThread().getName()+"1吃了第"+count+"个苹果");

count--;

public void method1() \{

synchronized (obj) \{//同步代码块,作用域精确

if (count>0) \{

System.out.println(Thread.currentThread().getName()+"2吃了第"+count+"个苹果");

count--;

@Override

public void run() \{

// 吃苹果

for (int i = 0; i < 50; i++) \{

//method();

method1();

public static void main(String\[\] args) \{

// 初始化对象

AppleDemo demo=new AppleDemo();

//创建线程，启动线程

Thread th1=new Thread(demo,"A");

th1.start();

Thread th2=new Thread(demo,"B");

th2.start();

Thread th3=new Thread(demo,"C");

th3.start();

输出结果：

![70 7][]

### 3.2.2互斥锁ReentrantLock ###

package day25.thread;

import java.util.concurrent.locks.ReentrantLock;

public class AppleLock implements Runnable \{

private int count=50;

//创建一个互斥锁

ReentrantLock lock=new ReentrantLock();

@Override

public void run() \{

for (int i = 0; i < 50; i++) \{

//上锁

lock.lock();

try \{

if (count>0) \{

System.out.println(Thread.currentThread().getName()+"吃了第"+count+"个苹果");

count--;

\} catch (Exception e) \{

// TODO: handle exception

\}finally \{

//释放锁

lock.unlock();

public static void main(String\[\] args) \{

// 初始化对象

AppleLock app=new AppleLock();

//启动三个线程

new Thread(app, "A").start();

new Thread(app, "B").start();

new Thread(app, "C").start();

输出结果：

![70 8][]

### 3.2.3死锁 ###

package day25.thread;

//死锁

public class DeadLockDemo implements Runnable\{

//全局变量

boolean isFlag=false;

Object obj=new Object();

Object obj1=new Object();

//一个线程执行A

public void methodA() \{

System.out.println("methodA=="+Thread.currentThread().getName());

synchronized (obj) \{

System.out.println("obj已经加锁");

synchronized (obj1) \{

System.out.println("访问obj1");

System.out.println("obj1访问结束");

System.out.println("obj已经解锁");

//一个线程执行B

public void methodB() \{

System.out.println("methodB=="+Thread.currentThread().getName());

synchronized (obj1) \{

System.out.println("----->obj1已经加锁");

synchronized (obj) \{

System.out.println("------>访问obj");

System.out.println("------>obj访问结束");

System.out.println("------>obj1解锁");

@Override

public void run() \{

if (!isFlag) \{

isFlag=!isFlag;

methodA();

\}else \{

methodB();

public static void main(String\[\] args) \{

// 创建对象

DeadLockDemo demo=new DeadLockDemo();

//启动两个线程

new Thread(demo, "A").start();

new Thread(demo, "B").start();

输出结果：

![70 9][]

## 3.3定时器Timer ##

package day25.timer;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

import java.util.Timer;

import java.util.TimerTask;

class Task extends TimerTask\{

@Override

public void run() \{

// 计时器要执行的任务

System.out.println("上九天揽月，下五洋捉鳖！");

public class TimerDemo \{

public static void main(String\[\] args) throws ParseException \{

// 创建一个计时器对象，可以设置为守护线程+true

Timer timer=new Timer();

//添加执行的任务

//获取当前时间戳

Calendar c=Calendar.getInstance();

Long times=c.getTimeInMillis();

//3s后执行

times+=3\*1000;

//设置时间

c.setTimeInMillis(times);

//获取日期

Date date=c.getTime();

//指定时间

SimpleDateFormat frm=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

//将String类型的时间解析为Date

date=frm.parse("2018-08-17 16:39:40");

Task ts=new Task();

timer.schedule(new Task(), date);//在指定的时间来执行指定的任务

timer.schedule(new TimerTask() \{

@Override

public void run() \{

// 执行任务

System.out.println("送你一颗小星星");

\}, 5000);//以当前时间延迟多少毫秒执行一次任务

//指定首次出现时间

date=frm.parse("2018-08-17 16:45:00");

timer.schedule(new TimerTask() \{

@Override

public void run() \{

System.out.println("我不要！");

\}, date, 10000);//在指定的时间执行任务，以一定的延时重复执行

timer.schedule(new TimerTask() \{

@Override

public void run() \{

System.out.println("那就分手吧！");

\}, 2000, 5000);//以当前时间延迟多少s，再以固定的时间重复执行

//取消指定任务

//ts.cancel();

//取消timer内所有任务

//ts.cancel();

//清空已结束任务

//System.out.println(timer.purge());

输出结果：

![70 10][]

## 3.4单例设计模式 ##

> /\*\*
> 
>  \* 单例设计模式
> 
>  \* 当前该类只能有一个对象，这个对象是共享的
> 
>  \* \*/

### 3.4.1懒汉模式 ###

package day25.singleton;

//懒汉模式

public class SingletonDemo \{

String name;

private static SingletonDemo singleton=null;

//构造方法私有化

private SingletonDemo()\{

//通过类来获取对象，设计一个静态的方法

public static synchronized SingletonDemo getIntance() \{

//创建对象，返回对象

if (singleton==null) \{

singleton=new SingletonDemo();//初始化一个对象

return singleton;//将对象返回到方法调用处

package day25.singleton;

public class TestDemo \{

public static void main(String\[\] args) \{

/\*SingletonDemo demo=SingletonDemo.getIntance();

demo.name="zz";

System.out.println(demo);

SingletonDemo demo1=SingletonDemo.getIntance();

System.out.println(demo1);

System.out.println(demo1.name);\*/

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo.getIntance());

\}).start();;

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo.getIntance());

\}).start();;

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo.getIntance());

\}).start();;

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo.getIntance());

\}).start();;

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo.getIntance());

\}).start();;

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo.getIntance());

\}).start();;

输出结果：

![70 11][]

### 3.4.2饿汉模式 ###

package day25.singleton;

//饿汉模式

public class SingletonDemo1 \{

private static final SingletonDemo1 singleton=new SingletonDemo1();

//构造方法私有化

private SingletonDemo1()\{

//通过类来获取对象，设计一个静态的方法

public static synchronized SingletonDemo1 getIntance() \{

return singleton;

package day25.singleton;

public class TestDemo1 \{

public static void main(String\[\] args) \{

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo1.getIntance());

\}).start();

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo1.getIntance());

\}).start();

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo1.getIntance());

\}).start();

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo1.getIntance());

\}).start();

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo1.getIntance());

\}).start();

new Thread(new Runnable() \{

@Override

public void run() \{

System.out.println(SingletonDemo1.getIntance());

\}).start();

输出结果：

![70 12][]

## 3.5生产者消费者模型 ##

package day25.test;

> /\*\*
> 
>  \* 生产者与消费者模型中，要保证以下几点：
> 
>  \* 1 同一时间内只能有一个生产者生产     生产方法加锁sychronized
> 
>  \* 2 同一时间内只能有一个消费者消费     消费方法加锁sychronized
> 
>  \* 3 共享空间空时消费者不能继续消费     消费前循环判断是否为空，空的话将该线程wait，释放锁允许其他同步方法执行
> 
>  \* 4 共享空间满时生产者不能继续生产     生产前循环判断是否为满，满的话将该线程wait，释放锁允许其他同步方法执行
> 
>  \*/

> /\*\*
> 
>  \* 生产者: 一直生产,直到生产完10个
> 
>  \* 在生产过程中,如果库存中存满(1个)则停止生产(由resource控制)
> 
>  \*/

//生产者

class  Producer implements Runnable\{

private  ShareResource  resource;//共享资源对象

public Producer(ShareResource resource) \{

this.resource=resource;

@Override

public void run() \{

System.out.println("生产中。。。");

for (int prodect = 1; prodect <=100; prodect++) \{

try \{

resource.setProdect(prodect);

\} catch (InterruptedException e) \{

// TODO 自动生成的 catch 块

e.printStackTrace();

> /\*\*
> 
>  \* 消费者:不断消费,直到消费10个
> 
>  \*        消费过程中,如果库存有包子则消费,没包子等待(resource中wait())
> 
>  \*/

//消费者

class    Consumer implements Runnable\{

private  ShareResource  resource;//共享资源对象

public Consumer(ShareResource resource) \{

this.resource=resource;

@Override

public void run() \{

System.out.println("消费中。。。");

for (int i = 1; i <= 100; i++) \{

try \{

resource.getProdect();

\} catch (InterruptedException e) \{

// TODO 自动生成的 catch 块

e.printStackTrace();

> /\*\*
> 
>  \* 共享资源: 负责控制库存,如果库存没包子了:通知生产者开始生产(notify), 并且通知消费者等待(wait)
> 
>  \*                  ,如果库存有包子:通知生产者停止生产(wait),   并且通知消费者开始消费(notify)
> 
>  \*                  notify() / notifyall() :通知 实质上相当于 唤醒
> 
>  \* 加synchronized 为了保证,同一时刻只有一个生产者在生产,只有一个消费者在消费
> 
>  \*/

//共享资源

class ShareResource\{

private int prodect=-1;

public synchronized void setProdect(int prodect) throws InterruptedException \{

waitIfFull();//如果满,等待   被唤醒后继续执行

this.prodect=prodect;

System.out.println("生产包子"+prodect+"个");

notify();

public synchronized int getProdect() throws InterruptedException \{

waitIfEmpty();//如果空,等待  被唤醒后继续执行

int p=this.prodect;

System.out.println("消费者购买了"+p+"个包子");

this.prodect=-1;

notify();

return p;

private synchronized void waitIfEmpty() throws InterruptedException \{

if (prodect==-1) \{

System.out.println("消费者等待！");

wait();

private synchronized void waitIfFull() throws InterruptedException \{

if (prodect!=-1) \{

System.out.println("生产者等待！");

wait();

public class ProducterComsumerDemo \{

public static void main(String\[\] args) \{

//初始化对象

ShareResource resource=new ShareResource();

//启动线程

new Thread(new Producer(resource)).start();

new Thread(new Consumer(resource)).start();

输出结果：

![70 13][]

4.知识框架

![70 14][]

[70]: /images/20220516/331a376ed21c4544957ba1e995c2ec12.png
[70 1]: /images/20220516/762280493a7945049d80741c68059616.png
[70 2]: /images/20220516/e5f7af583e5f4599bf3d64f225cebd36.png
[70 3]: /images/20220516/4889d44a8a7b4780bd9a1ad53e116cf7.png
[70 4]: /images/20220516/98fe109734494717b82b30ea2b8ed8e0.png
[70 5]: /images/20220516/23e8495c0b4a4d3497bcb7cf7f6e16b5.png
[70 6]: /images/20220516/13f14838f4b24e8d881364be4f43603b.png
[70 7]: /images/20220516/c7d6a6b73e2a4c8d926b9692eb7d6eaf.png
[70 8]: /images/20220516/7edcd60d503845e596f88bcc871ff0f1.png
[70 9]: /images/20220516/6555a4840fe941328a99f477b5c0c4ad.png
[70 10]: /images/20220516/a0858e0dde3b4855a6ae68438a1b26b6.png
[70 11]: /images/20220516/51ac4470873e48a6aed0045489e87c57.png
[70 12]: /images/20220516/416afa8c67f44d76af9e8aeda062766c.png
[70 13]: /images/20220516/da2e6530dca8443e975180af449cf70a.png
[70 14]: /images/20220516/94a3d337924f471e9dcc5d173521c3d6.png