Java多线程Thread和Runnable（总结）
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java多线程Thread和Runnable（总结），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13113字，纯文字阅读大概需要19分钟。
内容图文
一、Java多线程常用的两种实现方法
1、 继承Thread类
-
子类继承Thread类具备多线程能力
-
启动线程：子类对象.start()
不建议使用：避免OOP单继承局限性
2、 实现Runnable接口
- 实现接口Runnable接口具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
new Thread(new ClassImplementRunnable()).start()
推荐使用Runnable：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用（静态代理）。
一份资源，多个代理
//一份资源
StartThread station = new StartThread();
//多个代理
new Thread(station,"user_a").start();
new Thread(station,"user_b").start();
new Thread(station,"user_c").start();
例子-龟兔赛跑
//模拟龟兔赛跑
public class Race implements Runnable {
private static String winner;
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
//让兔子睡觉
if(Thread.currentThread().getName().equals("兔子") && i==40){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (getWinner(i)) {
break;
}
}
}
//判断是否完成比赛
public boolean getWinner(int step) {
//判断是否有胜利者
if (winner != null) {
return true;
} else {
if (step >= 100) {
winner = Thread.currentThread().getName();
System.out.println("winner is " + winner);
return true;
} else {
return false;
}
}
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"乌龟").start();
new Thread(race,"兔子").start();
}
}
二、静态代理
- 真实对象和代理对象都要实现同一个接口；
- 代理对象要代理真实角色；
优点：
- 代理对象可以做真实对象做不了的事情(before，after)。
- 真实对象专注做自己的事情。
三、Lamda表达式
理解Function Interface(函数式接口)是学习Java8 lamda表达式的关键坐在。
函数式接口定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
public interface Runnable(){
public abstract void run();
}
- 对于函数式接口，我们可以通过lambda表达式创建该接口的对象。
Lamda表达式的演化：
//推导lamda表达式
public class TestLamda1 {
//3.静态内部类
static class Like2 implements ILike{
@Override
public void lamda() {
System.out.println("i like lamda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lamda();
like = new Like2();
like.lamda();
//4.局部内部类
class Like3 implements ILike{
@Override
public void lamda() {
System.out.println("i like lamda3");
}
}
like = new Like3();
like.lamda();
//5.匿名内部类,没有类的名称，必须借助接口或者父类
like = new ILike() {
@Override
public void lamda() {
System.out.println("i like lamda4");
}
};
like.lamda();
//6.用lamda简化
like = () -> {
System.out.println("i like lamda5");
};
like.lamda();
}
}
//1.定义一个函数式接口
interface ILike{
void lamda();
}
//2.实现类(常规用法)
class Like implements ILike{
@Override
public void lamda() {
System.out.println("i like lamda");
}
}
lambda表达式简化：
- lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹；
- 前提是接口为函数式接口；
- 多个参数也可以去掉参数类型要去掉就都去掉，必须加上括号。
例：
love = (int a, int b) -> {
System.out.println("1");
System.out.println("2");
}
//简化为
love = (a,b) -> {
System.out.println("1");
System.out.println("2");
}
四、线程的状态
1、线程状态相关API
- setPriority(int newPriority) 更改线程的优先级
- static void sleep(long millis) 在指定的毫秒内让当前正在执行的线程休眠
- void join() 等待该线程终止
- static void yield() 暂停当前正在执行的线程对象，并执行其他线程
- void interrupt() 中断线程（不建议使用）
- boolean isAlive() 测试线程是否处于活状态
2、线程休眠 sleep
- sleep（时间）指定当前线程阻塞的毫秒数；
- sleep存在异常InterruptedException;
- sleep时间达到后线程进入就绪状态；
- sleep可以模拟网络延时，到计时等；
- 每一个对象都有一个锁，sleep不会释放锁；
常用功能：
模拟网络延时、倒计时
//模拟倒计时
public static void tenDown(int num){
while (true){
System.out.println(num--);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(num < 0){
break;
}
}
}
3、线程礼让 yield
- 礼让线程，让当前正在执行的线程暂停，但不阻塞；
- 将线程从运行状态转为就绪状态；
- 让cpu重新调度，礼让不一定成功，看cpu心情
//测试礼让
public class TestYield implements Runnable{
public static void main(String[] args) {
TestYield testYield = new TestYield();
new Thread(testYield,"a").start();
new Thread(testYield,"b").start();
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始执行...");
//礼让
Thread.yield();
System.out.println(Thread.currentThread().getName() + "结束执行。");
}
}
4、线程合并 join
- Join合并线程，待此线程执行完成之后，再执行其他线程，其他线程阻塞；
- 可以想象成插队
//测试Join方法(可以想象为插队)
public class JoinTest implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程vip来了：" + i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动vip线程
//现在和main线程在同一个起跑线，当main线程到100时，礼让线程vip
JoinTest joinTest = new JoinTest();
Thread thread = new Thread(joinTest);
thread.start();
//main线程计数
for (int i = 0; i < 200; i++) {
if(i==100){
thread.join();//插队
}
System.out.println("main线程" + i);
}
}
}
5、线程状态观测 State
- NEW
尚未启动的线程处于此状态。 - RUNNABLE
在Java虚拟机中执行的线程处于此状态。 - BLOCKED
被阻塞的等待监视器锁定的线程处于此状态。 - WAITING
正在等待另一个线程执行特定动作的线程处于此状态。 - TIMED WATING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。 - TERMINATED
已退出的线程处于此状态。
5、线程优先级 Priority
-
Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
-
线程的优先级用数字表示，范围1~10
Thread.MIN_PRIORITY = 1; -
获取/改变优先级
getPriority() / setPriority(int xxx)
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度。
5、守护线程 daemon
- 线程分为用户线程和守护线程；
- 虚拟机必须确保用户线程执行完毕（main线程）；
- 虚拟机不用等待线程执行完毕；
- 如，后台记录操作日志、监控内存、垃圾回收等待；
五、线程同步
多个线程操作同一个对象
1、线程同步
处理多线程问题时，多个线程访问同一个对象（并发问题），并且某个线程还想修改这个对象。这时候就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的进程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
例子：
//不安全的买票
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
Thread th1 = new Thread(buyTicket,"小明");
Thread th2 = new Thread(buyTicket,"小红");
Thread th3 = new Thread(buyTicket,"小毛");
th1.start();
th2.start();
th3.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();
}
}
}
public void buy() throws InterruptedException {
//判断是否有票
if(ticketNums <= 0){
flag = false;
return;
}
//模拟延时
Thread.sleep(1000);
//买票
System.out.println(Thread.currentThread().getName() + "买到了第" + ticketNums-- + "张票");
}
}
分析为什么会出现三个线程买同一张票的问题（重要！）
JMM(Java Memory Model),是一种基于计算机内存模型，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。保证共享内存的原子性、可见性、有序性（这三个也是多线程的三大特性,划重点，面试经常问）。
可见性：
- 多线程操作共享内存时，执行结果能够及时的同步到共享内存，确保其他线程对此结果及时可见。
- 同一进程下的多个线程，内存资源是共享的。主内存的count才是共享资源。程序猿学社、隔壁老王、小张，实际上不是直接对主内存的count进行写入操作。实际上，程序运行过程中，他们每个人，都有各自的工作内存。实际上就是把主内存的count，每个人，都copy一份，对各自的工作内存的变量进行操作。操作完后，再把对应的结果通知到主内存。
说了这么多，我们这时候应该知道之前写的模拟抢票demo为什么会有线程安全问题了把。就是因为各自都操作自己的工作内存，拿到主内存的值就开始操作。假设，这时候count为40，同一时间，来了三个线程，那这三个线程的工作内存拿到的值都是40，这样就会导致，这三个线程，都会抢到39这张票。
2、队列 和 锁
- 同步方法
//安全的买票
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
Thread th1 = new Thread(buyTicket,"小明");
Thread th2 = new Thread(buyTicket,"小红");
Thread th3 = new Thread(buyTicket,"小毛");
th1.start();
th2.start();
th3.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();
}
}
}
//synchronized 同步方法,锁的是this
public synchronized void buy() throws InterruptedException {
//判断是否有票
if(ticketNums <= 0){
flag = false;
return;
}
//模拟延时
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName() + "买到了第" + ticketNums-- + "张票");
}
}
- 同步代码块
//线程安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
//synchronized同步块
synchronized (list) {
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
3、死锁
多个线程各自占有一些共享的资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步代码块同时拥有“两个以上对象的锁”，就可能发生“死锁”问题。
4、Lock锁
- 从JDK5开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当，
- ReentrantLock类实现了Lock,他拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentanctLock,可以显示加锁、释放锁。
synchronized与Lock的对比
- Lock是显示锁（手动开启和关闭锁，别忘记关闭锁）synchronized是隐式锁，出了作用域自定释放；
- Lock只有代码块锁，synchronized有代码块锁和方法锁；
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
- 优先使用顺序：
Lock > 同步代码块（已经进入了方法体，分配了相应资源）> 同步方法（在方法体之外）
六、线程协作
1、线程通信相关API
- wait() 表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁；
- notify() 唤醒一个处于等待状态的线程；
- notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度；
//1、测试生产者和消费者模型 --> 利用缓冲区解决：管程法
//生产者，消费者，产品，缓冲区
public class TestPC {
public static void main(String[] args) {
Container container = new Container();
Productor productor = new Productor(container);
Consumer consumer = new Consumer(container);
new Thread(productor).start();
new Thread(consumer).start();
}
}
//生产者
class Productor implements Runnable{
Container container = new Container();
public Productor(Container container) {
this.container = container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("生产了" + i + "只鸡");
container.push(new Chiecken(i));
}
}
}
//消费者
class Consumer implements Runnable{
Container container = new Container();
public Consumer(Container container) {
this.container = container;
}
//消费
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了-->" + container.pop().id + "只鸡");
}
}
}
//产品
class Chiecken{
int id;
public Chiecken(int id) {
this.id = id;
}
}
//缓冲区
class Container{
//需要一个容器存放产品
Chiecken[] chieckens = new Chiecken[10];
//容器计数器
int count = 0;
//生产者放入产品
public synchronized void push(Chiecken chiecken){
//如果容器满了，就需要等待消费者消费
if(count == chieckens.length){
//通知消费者消费，生产等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没满，我们就需要丢入产品
chieckens[count] = chiecken;
count ++;
//可以通知消费者消费了
this.notifyAll();
}
//消费者消费产品
public synchronized Chiecken pop(){
if(count == 0){
//等待生产者生产，消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果可以消费
count --;
Chiecken chiecken = chieckens[count];
//吃完了，等待消费者生产
this.notifyAll();
return chiecken;
}
}
//2、解决生产者和消费者问题 信号灯法
public class TestPC2 {
public static void main(String[] args) {
Show show = new Show();
Player player = new Player(show);
Watcher watcher = new Watcher(show);
new Thread(player).start();
new Thread(watcher).start();
}
}
//演员
class Player implements Runnable{
Show show;
public Player(Show show){
this.show = show;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i%2 == 0){
this.show.play("钢铁侠");
}else {
this.show.play("绿巨人");
}
}
}
}
//观众
class Watcher implements Runnable{
Show show;
public Watcher(Show show) {
this.show = show;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
this.show.watch();
}
}
}
//产品————>表演
class Show {
//演员表演,观众等待 T
//观众观看，演员等待 F
boolean flag = true;
String voice;
//表演
public synchronized void play(String voice) {
if(!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("表演了" + voice);
this.voice = voice;
//通知观看
this.notifyAll();
flag = !flag;
}
//观看
public synchronized void watch(){
if(flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了" + voice);
//通知表演
this.notifyAll();
flag = !flag;
}
}
2、线程池
背景：经常创建和销毁、使用大量特别大的资源，比如并发情况下的线程，对性能影响很大，使用线程池便于线程管理。
- ExecutorService
- Executors
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
{
}
内容总结
以上是互联网集市为您收集整理的Java多线程Thread和Runnable（总结）全部内容，希望文章能够帮你解决Java多线程Thread和Runnable（总结）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】