Java并发/多线程

最新推荐文章于 2024-03-20 10:15:00 发布
最新推荐文章于 2024-03-20 10:15:00 发布
阅读量119 收藏 1
点赞数
分类专栏： 面试准备 Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/O2AtomLife/article/details/84183641
版权

Java多线程

实现线程的两种方法：

a. 继承Thread类，start（）启动。

b. 实现Runnable接口，实现run方法。

 

1. 基本线程

package com.sam.thread;

public class SimpleThread extends Thread {
    private int countDown = 5;
    private static int threadCount = 0;

    public SimpleThread() {
        super(" " + ++threadCount); // store the thread name
        start();
    }

    public String toString() {
        return "#" + getName() + ": " + countDown;
    }

    public void run() {
        while (true) {
            System.out.println(this);
            if (--countDown == 0)
                return;
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new SimpleThread();
        }
    }
}

package com.sam.thread;

public class SimpleThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public SimpleThread() {
		super(" " + ++threadCount); // store the thread name
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new SimpleThread();
		}
	}
}

结果：

# 1: 5
# 1: 4
# 1: 3
# 1: 2
# 1: 1
# 3: 5
# 3: 4
# 3: 3
# 3: 2
# 3: 1
# 2: 5
# 5: 5
# 5: 4
# 5: 3
# 5: 2
# 5: 1
# 2: 4
# 2: 3
# 2: 2
# 2: 1
# 4: 5
# 4: 4
# 4: 3
# 4: 2
# 4: 1
 

 

 

2.yield（），让步，让其它线程使用CPU，可以让结果更均衡。

package com.sam.thread;

public class YieldThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public YieldThread() {
		super(" " + ++threadCount); // store the thread name
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
			yield();
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new YieldThread();
		}
	}
}

 结果：

# 1: 5
# 2: 5
# 3: 5
# 1: 4
# 2: 4
# 5: 5
# 3: 4
# 1: 3
# 5: 4
# 3: 3
# 1: 2
# 5: 3
# 3: 2
# 1: 1
# 5: 2
# 4: 5
# 3: 1
# 5: 1
# 2: 3
# 4: 4
# 2: 2
# 2: 1
# 4: 3
# 4: 2
# 4: 1

 

3. sleep， 休眠一段时间再执行

package com.sam.thread;

public class SleepThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public SleepThread() {
		super(" " + ++threadCount); // store the thread name
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
			try {
				sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new SleepThread();
		}
	}
}

 结果：

# 1: 5
# 3: 5
# 2: 5
# 5: 5
# 4: 5
# 1: 4
# 2: 4
# 4: 4
# 3: 4
# 5: 4
# 1: 3
# 2: 3
# 3: 3
# 4: 3
# 5: 3
# 2: 2
# 4: 2
# 3: 2
# 1: 2
# 5: 2
# 1: 1
# 2: 1
# 4: 1
# 3: 1
# 5: 1

 

4. 优先级 setPriority();

package com.sam.thread;

public class PriorityThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public PriorityThread(int priority) {
		super(" " + ++threadCount); // store the thread name
		setPriority(priority);
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;			
		}
	}

	public static void main(String[] args) {
		new PriorityThread(Thread.MAX_PRIORITY);
		for (int i = 0; i < 5; i++) {
			new PriorityThread(Thread.MIN_PRIORITY);
		}
	}
}

 结果：优先级高的先运行

# 1: 5
# 1: 4
# 1: 3
# 1: 2
# 1: 1
# 3: 5
# 3: 4
# 3: 3
# 3: 2
# 3: 1
# 5: 5
# 5: 4
# 5: 3
# 5: 2
# 5: 1
# 2: 5
# 2: 4
# 2: 3
# 2: 2
# 2: 1
# 4: 5
# 4: 4
# 4: 3
# 6: 5
# 6: 4
# 6: 3
# 6: 2
# 6: 1
# 4: 2
# 4: 1

 

5. 后台线程（daemon）

当所有非后台线程结束，线程终止。如：某个时刻线程都sleep了，程序终止。

package com.sam.thread;

public class DaemonThread extends Thread {
	private int countDown = 5;
	private static int threadCount = 0;

	public DaemonThread() {
		super(" " + ++threadCount); // store the thread name
		setDaemon(true);
		start();
	}

	public String toString() {
		return "#" + getName() + ": " + countDown;
	}

	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
			try {
				sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}

	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			new DaemonThread();
		}
	}
}

 结果：

# 1: 5
# 3: 5
# 5: 5
# 4: 5
# 2: 5

 

6. join（）和interrupt（）

package com.sam.thread;

class A extends Thread {
	public A() {
		start();
	}
	public void run() {
		try {
			System.out.println("A started.");
			sleep(1000);
		} catch (InterruptedException e) {
			System.out.println("Sleep interrupted");
		}
	}
}

public class JoinThread extends Thread {
	A a;
	public JoinThread(A a) {
		this.a = a;
		start();
	}
	public void run() {
	
		try {
			a.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("JoinThread started.");
	}
	public static void main(String[] args) {
		A a = new A();
		JoinThread jt = new JoinThread(a);
		a.interrupt();
	}
}

 结果：

A started.
Sleep interrupted
JoinThread started.

 

7. Runnable接口

package com.sam.thread;

public class RunnableThread implements Runnable {

	private int countDown = 5;

	public String toString() {
		return "#" + Thread.currentThread().getName() + ": " + countDown;
	}

	@Override
	public void run() {
		while (true) {
			System.out.println(this);
			if (--countDown == 0)
				return;
		}
	}

	public static void main(String[] args) {
		for (int i = 1; i <= 5; i++) {
			new Thread(new RunnableThread(), "" + i).start();
		}
	}
}

runnable接口本身不带线程的特性，要运行，还是要建立一个单独的Thread对象。

 

8. 不正确地访问资源

package com.sam.thread;

public class AlwaysEven {
	int i;

	void next() {
		i++;
		i++;
	}

	int get() {
		return i;
	}

	public static void main(String[] args) {
		final AlwaysEven ae = new AlwaysEven();
		new Thread() {
			public void run() {
				while (true) {
					int j = ae.get();
					if (j % 2 != 0) {
						System.out.println(j);
						System.exit(0);
					}
				}
			}
		}.start();
		while (true) {
			ae.next();
		}
	}
}

 结果：

1501

 

9. 解决共享资源竞争

在每个访问共享资源的方法上都要加上synchronized,否则不加的方法会忽视该锁。

package com.sam.thread;

public class AlwaysEven {
	int i;

	synchronized void next() {
		i++;
		i++;
	}

	synchronized int get() {
		return i;
	}

	public static void main(String[] args) {
		final AlwaysEven ae = new AlwaysEven();
		new Thread() {
			public void run() {
				while (true) {
					int j = ae.get();
					if (j % 2 != 0) {
						System.out.println(j);
						System.exit(0);
					}
				}
			}
		}.start();
		while (true) {
			ae.next();
		}
	}
}

 

10. volatile

禁止编译器进行优化，线程不能保留该对象的私有拷贝，影响效率。

 

11. 临界区

防止多个线程访问方法中的部分代码。

synchronized(syncObject) {
    // This code can only be access
    // by one thread at a time
}

 

12. 线程的状态

新建（new）

就绪（Runnable）

死亡（Dead）

阻塞（Blocked）

 

13. notify（）

唤醒wait（）中的线程。

 

zz

O2AtomLife
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA多线程并发
陪你听风的博客
04-18 1913
简介 1.什么是多线程？ 说起多线程，那么就不得不说什么是线程，而说起线程，又不得不说什么是进程。 进程可以简单的理解为一个可以独立运行的程序单位。它是线程的集合，进程就是有一个或多个线程构成的，每一个线程都是进程中的一条执行路径。 那么多线程就很容易理解：多线程就是指一个进程中同时有多个执行路径（线程）正在执行。 2.为什么要是用多线程（优缺点）？ ...
Java 并发 / 多线程教程
05-18 1163
Java 并发 / 多线程教程原文链接：http://tutorials.jenkov.com/java-concurrency/index.html内容列表 Java 中的多线程和并发 Java 并发 2015 和展望 最开始的计算机只有一个 CPU ，一次也只能执行一个程序。后来，出现了多任务操作系统，在宏观上能同时执行多个程序。实际上，在同一时刻只能执行一个程序，多个程序共享一个 CPU 。操
Java多线程 - 并行/并发/进程/线程/多线程意义
你今天真好看呀
02-16 2476
1. 并行和并发有什么区别？ 并发和并行都可以处理“多任务”，二者的主要区别在于是否是“同时进行”多个的任务。 串行：按先后顺序做多件事情；例如：A事情完成，才能做B事情； 并行：指同一时刻同时做多件事情；比如：A事情和B事情同时进行； 并发：指同一时间间隔内做多件事情；比如：操作系统将CPU的时间片分时让给A事情和B事情，仿佛是同时执行； 并发：不同的代码块交替执行 并行：不同的代码块同时执行 (1) 并行：指在同一时刻，多个指令可以在多个处理器上同时执行。 (2) 并发：指在同一时
Java多线程并发编程技术详解
最新发布
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 2万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
Java 并发和多线程
m0_72674204的博客
08-14 750
Java并发和多线程
使用java的HttpClient实现多线程并发
09-01
通过使用HttpClient的连接池和多线程，我们可以有效地并发执行HTTP GET请求，同时控制并发数量，避免过多的网络连接导致服务器压力过大。这种方式提高了请求效率，减少了资源消耗，并且遵循了最佳实践。
Java多线程之并发工具类
12-22
Java并发工具类是Java多线程编程中必不可少的一部分，它们为开发者提供了更加高效和灵活的线程同步机制。本文将详细介绍三个重要的并发工具类：CountDownLatch、CyclicBarrier和Semaphore。 首先，CountDownLatch是...
vvvvvvvvvvvvvvvvvvvvvvvvv
SAm
04-24 6470
Java Concurrency In Practice Brian Göetz Tim Peierls Joshua Bloch Joseph Bowbeer David Holmes Doug Lea Addison‐Wesley Professional ISBN‐10: 0‐321‐34960‐1 ISBN‐13: 978‐0‐321‐34960‐6 ii Jav...
Thread stop不能用了
SAm
12-19 306
http://docs.oracle.com/javase/6/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html http://www.cnblogs.com/gpcuster/archive/2010/01/18/1650273.html Java Thread Primitive Deprecation ...
用java编写简单Webserver，理解webserver的功能。
SAm
01-08 287
from http://www.cnblogs.com/wangrui-techbolg/archive/2013/03/10/2953108.html.   文件处理类 processer.java package webbook.chapter2; import java.io.*; import java.net.Socket; /** * 处理一个HTTP用户请求...
how tomcat works
SAm
09-11 206
how tomcat works, chinese and english
Java中Split函数的用法技巧
SAm
02-09 176
&lt;!-- [if gte mso 9]&gt;&lt;xml&gt; &lt;o:OfficeDocumentSettings&gt; &lt;o:RelyOnVML/&gt; &lt;o:AllowPNG/&gt; &lt;/o:OfficeDocumentSettings&gt; &lt;/xml&gt;&lt;![endif]--&gt;&
java 集合类图形解释
SAm
04-30 144
转自： http://messon619.iteye.com/blog/642277 数组类Array。是JAVA中最基本的一个存储结构。它用于存储一组连续的对象或基本类型的数据。其中的元素的类型必须相 同。array是最有效率的一种。1、效率高，但容量固定且无法动态改变。 array还有一个缺点是，无法判断其中实际存有多少元素，length只是告诉我们array的容量。 ...
change package and import
SAm
07-25 134
package util; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; impo...
深入研究java.lang.ThreadLocal类
SAm
03-08 99
深入研究java.lang.ThreadLocal类     一、概述   ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是 threadlocalvariable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量 (ThreadLocal)其实的功用非常简...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值