本文详细介绍了Java线程的创建、控制与管理，包括设置优先级、休眠、礼让、join、中断、状态观测、守护线程、线程同步、死锁、Lock接口、线程池及线程创建的三种方式。通过实例展示了线程的生命周期、状态转换，以及如何安全地停止线程。此外，还讨论了线程通信、生产者消费者模型和线程池的概念，强调了线程池在提升性能和资源管理方面的重要性。
线程方法
-
更改线程优先级 setPriority（int newPriority）
-
指定的毫米数内让当前执行的线程休眠（static void sleep（long millis））
-
等待该线程终止（void join（））
-
暂停当前正在执行的线程对象，并执行其他线程 static void yield（）
-
中断线程（勿用，容易搞出事）
-
测试线程是否处于活动状态
停止线程的方法
一般使用标志flag，让线程自己停止
package com.wang.Thread.state;
//测试停止线程
//1.利用次数，让线程正常停止
//2.利用标志位
//3.不要使用stop或destroy等JDK不建议使用的方法
public class TestStop implements Runnable{
private boolean flag = true;
@Override
public void run(){
int i = 0;
while (flag){
System.out.println("Run Thread"+i++);
}
}
//设置一个公开的方法停止线程（转换标志位）
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i);
if (i==500){
testStop.stop();
System.out.println("线程停止了");
}
}
}
}
线程的休眠
-
sleep制定当前线程的阻塞毫秒数
-
sleep存在异常interruptedException
-
sleep时间到达后线程进入就绪状态
-
sleep可以模拟网络延时，倒计时等
-
每一个对象都有一把锁，sleep不会释放锁
package com.wang.Thread.state;
import java.text.SimpleDateFormat;
import java.util.Date;
//模拟倒计时
public class TestSleep2 {
public static void main(String[] args) {
//打印当前系统时间
Date startTime = new Date(System.currentTimeMillis());
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime = new Date(System.currentTimeMillis());//更新当前时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//模拟倒计时
public static void tenDown() throws InterruptedException {
int num = 10;
while(true){
Thread.sleep(1000);
System.out.println(num--);
if (num<=0)
break;;
}
}
}
线程的礼让
-
让当前正在执行的线程暂停，但不阻塞
-
将线程从运行转为就绪
-
让CPU重新调度，礼让不一定成功，看CPU“心情”
package com.wang.Thread.state;
//测试礼让线程，礼让不一定成功
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread()+"线程开始执行");
Thread.yield();
System.out.println(Thread.currentThread()+"线程停止执行");
}
}
线程强制执行
-
Join合并线程，待此线程完成后，再执行其他线程，其他线程阻塞
-
插队
package com.wang.Thread.state;
//测试join方法，想象为插队
public class TestJoin implements Runnable{
@Override
public void run() {
//测试使用时一定要循环次数大，才比较明显
for (int i = 0; i < 10000; i++) {
System.out.println("插队的来了"+i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
TestJoin testJoin = new TestJoin();
Thread thread1 = new Thread(testJoin);
thread1.start();
for (int i = 0; i < 1000; i++) {
if(i==200){
thread1.join();
}
System.out.println("main"+i);
}
}
}
线程状态观测
-
NEW
-
RUNNABLE
-
BLOCKED
-
WAITTING
-
TIMED_WAITING
-
TERMINATED
package com.wang.Thread.state;
//观察测试线程的状态
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("OOOOOOOO");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);//new
//观察启动后
thread.start();
System.out.println(state);//run
//只要线程不终止，就一直输出状态
while(state!=Thread.State.TERMINATED){
Thread.sleep(10);
state = thread.getState();
System.out.println(state);
}
//死亡之后的线程无法再次启动
}
}
-
线程死亡后就不能再次启动
线程优先级
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
-
优先级用数字表示1-5-10
-
getPriority() setPriority()
package com.wang.Thread.state;
//测试线程的优先级
public class TestPriority {
public static void main(String[] args) {
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t0 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
Thread t5 = new Thread(myPriority);
t0.setPriority(2);
t0.start();
t1.start();
t2.setPriority(Thread.MIN_PRIORITY);
t2.start();
t3.setPriority(8);
t3.start();
t4.setPriority(Thread.NORM_PRIORITY);
t4.start();
t5.setPriority(Thread.MAX_PRIORITY);
t5.start();
//主线程优先级
System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--"+Thread.currentThread().getPriority());
}
}
优先级高的是可以先跑，但是不一定先运行，只是概率高，还是看CPU的调度
守护线程daemon
-
线程分为用户线程和守护线程
-
虚拟机必须确保用户线程执行完毕
-
虚拟机不用等待守护线程执行完毕
-
如：后台记录操作日志，监控内存，垃圾回收等
package com.wang.Thread.state;
//测试守护线程
//god bless u
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程
thread.start();
new Thread(you).start();
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("一生开心的活着");
}
System.out.println("goodbye world");
}
}
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝保佑着你");
}
}
}
线程同步 *
多个线程操作同一个对象(并发发生时) 秒杀机制 宏观上并行，微观上并发
需要访问该对象的线程进入该对象的对象等待池排队
-
锁机制(synchronized)
-
一个线程持有锁会导致其他线程挂起
-
多线程竞争，会额外的消耗系统资源
-
优先级高的等待优先级低的，导致优先级倒置，性能问题
-
不安全的案例:
package com.wang.Thread.syn;
//不安全的买票
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"dd").start();
new Thread(buyTicket,"ss").start();
new Thread(buyTicket,"aa").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true;
@Override
public void run() {
//买票
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
//判断是否有票
if(ticketNums<=0){
flag = false;
return;
}
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName()+"买到了"+ticketNums--);
}
}
同步方法
synchronized关键字机制
-
synchronize方法控制对this对象（默认对象）的访问
-
每个对象都有一把锁
-
每个synchronize方法都要拿到这个锁才能执行
-
结束时释放该锁
同步方法锁的太多，浪费资源
package com.wang.Thread.syn;
//安全的买票
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"dd").start();
new Thread(buyTicket,"ss").start();
new Thread(buyTicket,"aa").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true;
@Override
public void run() {
//买票
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//变成同步方法,锁的是this
private synchronized void buy() throws InterruptedException {
//判断是否有票
if(ticketNums<=0){
flag = false;
return;
}
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName()+"买到了"+ticketNums--);
}
}
同步块
-
synchronized（Obj）{}
-
称为同步监视器
-
Obj可以是任何对象，但是推荐使用共享资源做Obj
-
锁的是实际改变的对象
-
{}内为要锁住对象之后，才能进行的操作
-
package com.wang.Thread.syn;
import com.wang.OOP.A;
//安全，使用了synchronized
// 同步块
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100,"买房钱");
Drawing woman = new Drawing(account,100,"女方");
Drawing man = new Drawing(account,50,"男方");
man.start();
woman.start();
}
}
class Account{
int money;
String name;
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
class Drawing extends Thread{
Account account;
//取了多少钱
int drawingMoney;
//现在手里的钱
int nowMoney;
public Drawing(Account account,int drawingMoney,String name){
this.account = account;
this.drawingMoney = drawingMoney;
this.nowMoney = nowMoney;
}
public void run(){
synchronized (account){
if(account.money-drawingMoney<0){
System.out.println(Thread.currentThread().getName()+"没这么多钱");
return;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
account.money = account.money - drawingMoney;
nowMoney = nowMoney + drawingMoney;
System.out.println("余额为"+account.money);
System.out.println(this.getName()+"手里有"+nowMoney);
}
}
}
JUC 的CopyOnWriteArrayList
package com.wang.Thread.syn;
import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC安全类型的集合
public class TestJUC {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
});
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
死锁
package com.wang.Thread;
//死锁
//等待对方释放资源
public class DeadLock {
public static void main(String[] args) {
Makeup girl1 = new Makeup(1,"wang");
Makeup girl2 = new Makeup(0,"li");
girl1.start();
girl2.start();
}
}
class LipStick{
}
class Mirror{
}
class Makeup extends Thread{
static LipStick lipStick = new LipStick();
static Mirror mirror = new Mirror();
int choice;
String girlName;
@Override
public void run() {
makeup();
}
Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
private void makeup(){
if(choice==0){
synchronized (lipStick){
System.out.println(this.girlName+"拿到口红");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} synchronized (mirror){
System.out.println(this.girlName+"拿到镜子");
}
}
else{
synchronized (mirror){
System.out.println(this.girlName+"拿到镜子");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} synchronized (lipStick){
System.out.println(this.girlName+"拿到口红");
}
}
}
}
Lock(ReentrantLock)
和synchronized一模一样
-
ReentrantLock类实现了Lock，常用
-
用于同步问题中加锁
-
Lock锁性能更好
生产者消费者问题
synchronized不能用来实现不同线程之间的消息传递
-
缓冲区解决方式
-
信号灯法
线程通信
-
wait() 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
-
wait(long timeout) 指定等待的毫秒数
-
notify() 唤醒一个处于等待状态的线程
-
notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度
均是Object类的方法，都只能在同步方法或同步代码块中使用
package com.wang.Advanced;
import java.awt.*;
//测试生产者消费者模型
//利用缓冲区，管程法
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Productor(container).start();
new Consumer(container).start();
}
}
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("生产了"+i+"只鸡");
container.push(new Chicken(i));
}
}
}
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container){
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("吃了"+container.pop().id+"只鸡");
}
}
}
class Chicken{
int id;//产品编号
public Chicken(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer{
Chicken[] chickens = new Chicken[10];
int count = 0;
//生产者放入产品
public synchronized void push(Chicken chicken){
if(count == chickens.length){
//通知等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
chickens[count] = chicken;
this.notifyAll();
}
//放入产品
chickens[count] = chicken;
count++;
//通知消费
}
//消费者取出产品
public synchronized Chicken pop(){
if(count==0){
//等待生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count--;
Chicken chicken = chickens[count];
this.notifyAll();
return chicken;
}
}
信号灯法
缓存为1的管程法
线程池
提升性能
思路：提前创建许多线程放入线程池，使用时获取，用完放回，避免频繁销毁创建
-
提升响应速度-----减少创建线程的时间
-
降低资源消耗-----重复利用池中的线程
-
便于线程管理
-
corePoolSize 核心池的大小
-
maximumPoolSize 最大线程数
-
keepAliveTime 线程没有任务时最多保持多长时间后停止
-
package com.wang.Advanced;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试线程池
public class TestPool {
public static void main(String[] args) {
//1.创建服务，创建线程池
//newFixedThreadPool参数为大小
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//2.关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
总结线程的三种创建方法
package com.wang.Advanced;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
//回顾线程的创建
public class ThreadSummary {
public static void main(String[] args) {
new MyThread1().start();
new Thread(new MyThread2()).start();
FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
new Thread(futureTask).start();
try {
Integer integer = futureTask.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//1.继承Thread类
class MyThread1 extends Thread{
@Override
public void run() {
System.out.println("MY THREAD1");
}
}
//2.实现Runnable接口
class MyThread2 implements Runnable{
@Override
public void run() {
System.out.println("MY THREAD2");
}
}
//3.实现Callable接口
class MyThread3 implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println("MY THREAD3");
return 100;
}
}
扫一扫
218
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
