可能是东半球最好的多线程讲义!
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了可能是东半球最好的多线程讲义!相关的知识,希望对你有一定的参考价值。
JAVA多线程
多线程的基本概念
线程指进程中的一个执行场景,也就是执行流程,那么进程和线程有什么区别呢?
每个进程是一个应用程序,都有独立的内存空间
同一个进程中的线程共享其进程中的内存和资源(共享的内存是堆内存和方法区内存,栈内存不共享,每个线程有自己的。)
什么是进程?
一个进程对应一个应用程序。例如:在 windows 操作系统启动 Word 就表示启动了一个
进程。在 java 的开发环境下启动 JVM,就表示启动了一个进程。现代的计算机都是支持多
进程的,在同一个操作系统中,可以同时启动多个进程。
多进程有什么作用?
单进程计算机只能做一件事情。
玩电脑,一边玩游戏(游戏进程)一边听音乐(音乐进程)。
对于单核计算机来讲,在同一个时间点上,游戏进程和音乐进程是同时在运行吗?不是。
因为计算机的 CPU 只能在某个时间点上做一件事。由于计算机将在“游戏进程”和“音乐
进程”之间频繁的切换执行,切换速度极高,人类感觉游戏和音乐在同时进行。
多进程的作用不是提高执行速度,而是提高 CPU 的使用率。
进程和进程之间的内存是独立的。
什么是线程?
线程是一个进程中的执行场景。一个进程可以启动多个线程。
多线程有什么作用?
多线程不是为了提高执行速度,而是提高应用程序的使用率。
线程和线程共享“堆内存和方法区内存”,栈内存是独立的,一个线程一个栈。
可以给现实世界中的人类一种错觉:感觉多个线程在同时并发执行。
java 程序的运行原理?
java 命令会启动 java 虚拟机,启动 JVM,等于启动了一个应用程序,表示启动了一个进程。该进程会自动启动一个“主线程”,然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。
线程生命周期
线程是一个进程中的执行场景,一个进程可以启动多个线程
新建:采用 new 语句创建完成
就绪:执行 start 后
运行:占用 CPU 时间
阻塞:执行了 wait 语句、执行了 sleep 语句和等待某个对象锁,等待输入的场合
终止:退出 run()方法
多线程不是为了提高执行速度,而是提高应用程序的使用率.
线程和线程共享”堆内存和方法区内存”.栈内存是独立的,一个线程一个栈.
可以给现实世界中的人类一种错觉 : 感觉多线程在同时并发执行.
很多人都对其中的一些概念不够明确,如同步、并发等等,让我们先建立一个数据字典,以免产生误会。
多线程:指的是这个程序(一个进程)运行时产生了不止一个线程
并行与并发:
·
并行:多个cpu实例或者多台机器同时执行一段处理逻辑,是真正的同时。
·
并发:通过cpu调度算法,让用户看上去同时执行,实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源,那么针对这个公用的资源往往产生瓶颈,我们会用TPS或者QPS来反应这个系统的处理能力。
线程安全:经常用来描绘一段代码。指在并发的情况之下,该代码经过多线程使用,线程的调度顺序不影响任何结果。这个时候使用多线程,我们只需要关注系统的内存,cpu是不是够用即可。反过来,线程不安全就意味着线程的调度顺序会影响最终结果,如不加事务的转账代码:
void transferMoney(User from, User to, float amount) { to.setMoney(to.getBalance() + amount); from.setMoney(from.getBalance() - amount); }
同步:Java中的同步指的是通过人为的控制和调度,保证共享资源的多线程访问成为线程安全,来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时,提高性能,才是优秀的程序。线程安全的优先级高于性能。
Java命令会启动Java虚拟机,启动JVM,等于启动了一个应用程序,表示启动了一个进程,该进程会自动启动一个”主线程”,
然后主线程去调用某个类的main()方法,所以main()方法运行在主线程中.
线程的调度与控制
线程的调度模型分为: 分时调度模型和抢占式调度模型,Java使用抢占式调度模型
通常我们的计算机只有一个 CPU,CPU 在某一个时刻只能执行一条指令,线程只有得到 CPU时间片,也就是使用权,才可以执行指令。在单 CPU 的机器上线程不是并行运行的,只有在多个 CPU 上线程才可以并行运行。Java 虚拟机要负责线程的调度,取得 CPU 的使用权,目前有两种调度模型:分时调度模型和抢占式调度模型,Java 使用抢占式调度模型。分时调度模型:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间片抢占式调度模型:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的 CPU 时间片相对多一些。
l 分时调度模型: 所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片
l 抢占式调度模型: 优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的CPU时间片相对多一些.
public class ThreadTest {
public static void main(String[] args) {
ThreadTest1();
// ThreadTest2();
// ThreadTest3();
// ThreadTest4();
// ThreadTest5();
}
/**
* 三个方法: 获取当前线程对象:Thread.currentThread(); 给线程起名: t1.setName("t1"); 获取线程的名字:
* t.getName();
*/
private static void ThreadTest1() {
Thread t = Thread.currentThread();// t保存的内存地址指向的线程为"主线程"
System.out.println(t.getId());
Thread t1 = new Thread(new Processor1());
// 给线程起名
t1.setName("t1");
t1.start();
Thread t2 = new Thread(new Processor1());
t2.setName("t2");
t2.start();
}
/**
* 线程优先级高的获取的CPU时间片相对多一些 优先级: 1-10 最低: 1 最高: 10 默认: 5
*/
private static void ThreadTest2() {
Thread t1 = new Processor2();
Thread t2 = new Processor2();
t1.setName("t1");
t2.setName("t2");
System.out.println(t1.getPriority());
System.out.println(t2.getPriority());
t1.setPriority(1);
t2.setPriority(10);
t1.start();
t2.start();
}
/**
* 1.Thread.sleep(毫秒); 2.sleep方法是一个静态方法 3.该方法的作用: 阻塞当前线程,腾出CPU,让给其它线程
*/
private static void ThreadTest3() {
Thread t = new Thread(new Processor3());
t.start();
for (int i = 0; i < 11; i++) {
System.out.println(Thread.currentThread().getName() + "========>"
+ i);
try {
t.sleep(5000);// 等同于Thread.sleep(5000);阻塞的还是当前线程,和t线程无关.
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 某线程正在休眠,如何打断它的休眠 以下方式依靠的是异常处理机制
*/
private static void ThreadTest4() {
try {
Thread t = new Thread(new Processor4());
t.start();
Thread.sleep(5000);// 睡5s
t.interrupt();// 打断Thread的睡眠
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 如何正确的更好的终止一个正在执行的线程 需求:线程启动5s之后终止.
*/
private static void ThreadTest5() {
Processor5 p = new Processor5();
Thread t = new Thread(p);
t.start();
// 5s之后终止
try {
Thread.sleep(5000);
p.isRun = false;
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class Processor1 implements Runnable {
@Override
public void run() {
Thread t = Thread.currentThread();// t保存的内存地址指向的线程为"t1线程对象"
System.out.println(t.getName());
System.out.println(t.getId());
}
}
class Processor2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName()
+ "----------->" + i);
}
}
}
class Processor3 implements Runnable {
/**
* Thread中的run方法不能抛出异常,所以重写runn方法之后,在run方法的声明位置上不能使用throws
* 所以run方法中的异常只能try...catch...
*/
@Override
public void run() {
for (int i = 0; i < 11; i++) {
System.out.println(Thread.currentThread().getName() + "========>"
+ i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Processor4 implements Runnable {
@Override
public void run() {
try {
Thread.sleep(1000000000);
System.out.println("能否执行这里");
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 11; i++) {
System.out.println(Thread.currentThread().getName() + "========>"
+ i);
}
}
}
class Processor5 implements Runnable {
boolean isRun = true;
@Override
public void run() {
for (int i = 0; i < 11; i++) {
if (isRun) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "========>" + i);
}
}
}
}
线程优先级
线 程 优 先 级 主 要 分 三 种 : MAX_PRIORITY( 最 高 );MIN_PRIORITY ( 最 低 级 )NORM_PRIORITY(标准)默认
//设置线程的优先级,线程启动后不能再次设置优先级
//必须在启动前设置优先级
//设置最高优先级
t1.setPriority(Thread.MAX_PRIORITY);
sleep
public class SleepTest {
public static void main(String[] args) {
System.out.println("Wait");
// 让主线程等待5秒再执行
Wait.bySec(5);
// 提示恢复执行
System.out.println("start");
}
}
class Wait {
public static void bySec(long s) {
// sleep s个1秒
for (int i = 0; i < s; i++) {
System.out.println(i + 1 + "秒");
try {
// sleep1秒
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
停止一个线程
l 如果我们的线程正在睡眠,可以采用 interrupt 进行中断
l 通常定义一个标记,来判断标记的状态停止线程的执行
yield
它与 sleep()类似,只是不能由用户指定暂停多长时间,并且 yield()方法只能让同优先级的线程有执行的机会,采用 yieid 可以将 CPU 的使用权让给同一个优先级的线程
public class YieldTest {
public static void main(String[] args) {
FirstThread mt = new FirstThread();
SecThread mnt = new SecThread();
mt.start();
mnt.start();
}
}
class FirstThread extends Thread{
public void run(){
for(int i=0;i<5;i++){
System.out.println("第一个线程的第 "+(i+1)+"次运行");
Thread.yield(); //暂停线程
}
}
}
class SecThread extends Thread{
public void run(){
for(int i=0;i<5;i++){
System.out.println("第二个线程的第 "+(i+1)+"次运行");
Thread.yield();
}
}
}
join
当前线程可以调用另一个线程的 join 方法,调用后当前线程会被阻塞不再执行,直到被调用的线程执行完毕,当前线程才会执行
public class JoinTest extends Thread {
public JoinTest(String name) {
super(name);
}
public void run() {
for (int i = 0; i < 5; i++)
System.out.println(getName() + "" + i);
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i == 5) {
JoinTest tempjt = new JoinTest("半路加入的线程");
try {
tempjt.start();
tempjt.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+""+i);
}
}
}
synchronized
线程同步,指某一个时刻,指允许一个线程来访问共享资源,线程同步其实是对对象加锁,如果对象中的方法都是同步方法,那么某一时刻只能执行一个方法,采用线程同步解决以上的问题,我们只要保证线程一操作 s 时,线程 2 不允许操作即可,只有线程一使用完成 s 后,再让线程二来使用 s 变量
· 异步编程模型 : t1线程执行t1的,t2线程执行t2的,两个线程之间谁也不等谁.
· 同步编程模型 : t1线程和t2线程执行,t2线程必须等t1线程执行结束之后,t2线程才能执行,这是同步编程模型.
·
· 什么时候要用同步呢?为什么要引入线程同步呢?
· 1.为了数据的安全,尽管应用程序的使用率降低,但是为了保证数据是安全的,必须加入线程同步机制.
· 线程同步机制使程序变成了(等同)单线程.
· 2.什么条件下要使用线程同步?
· 第一: 必须是多线程环境
· 第二: 多线程环境共享同一个数据.
· 第三: 共享的数据涉及到修改操作.
// synchronized 是对对象加锁
// 采用 synchronized 同步最好只同步有线程安全的代码
// 可以优先考虑使用 synchronized 同步块
// 因为同步的代码越多,执行的时间就会越长,其他线程等待的时间就会越长
// 影响效率
public class TestWithdrawal {
public static void main(String[] args) {
// 创建两个线程
TestAccount r = new TestAccount();
Thread one = new Thread(r);
Thread two = new Thread(r);
one.setName("张三");
two.setName("张三的妻子");
// 启动线程
one.start();
two.start();
}
}
class Account {
private int balance = 500; // 余额
public int getBalance() {
return balance;
}
// 取款
public void withdraw(int amount) {
balance = balance - amount;
}
}
class TestAccount implements Runnable {
// 所有用TestAccount对象创建的线程共享同一个帐户对象
private Account acct = new Account();
public void run() {
for (int i = 0; i < 5; i++) {
makeWithdrawal(100);// 取款
if (acct.getBalance() < 0) {
System.out.println("账户透支了!");
}
}
}
private void makeWithdrawal(int amt) {
synchronized (acct) {
if (acct.getBalance() >= amt) {
System.out.println(Thread.currentThread().getName() + " 准备取款");
try {
Thread.sleep(500);// 0.5秒后实现取款
} catch (InterruptedException ex) {
}
// 如果余额足够,则取款
acct.withdraw(amt);
System.out.println(Thread.currentThread().getName() + " 完成取款,余额:"+acct.getBalance());
} else {
// 余额不足给出提示
System.out.println("余额不足以支付 "
+ Thread.currentThread().getName() + " 的取款,余额为 "
+ acct.getBalance());
}
}
}
}
死锁
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new Thread(new T1(o1, o2));
Thread t2 = new Thread(new T2(o1, o2));
t1.start();
t2.start();
}
}
class T1 implements Runnable {
Object o1;
Object o2;
T1(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2) {
}
}
}
}
class T2 implements Runnable {
Object o1;
Object o2;
T2(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1) {
}
}
}
}
守护线程
从线程分类上可以分为:用户线程(以上讲的都是用户线程),另一个是守护线程。守护线程是这样的,所有的用户线程结束生命周期,守护线程才会结束生命周期,只要有一个用户线程存在,那么守护线程就不会结束,例如 java 中著名的垃圾回收器就是一个守护线程,只有应用程序中所有的线程结束,它才会结束。
· 其它所有的用户线程结束,则守护线程退出!
· 守护线程一般都是无限执行的.
public class DaemonThread {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable2());
t1.setName("t1");
// 将t1这个用户线程修改成守护线程.在线程没有启动时可以修改以下参数
t1.setDaemon(true);
t1.start();
// 主线程
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "----->" + i);
Thread.sleep(1000);
}
}
}
class Runnable2 implements Runnable {
@Override
public void run() {
int i = 0;
while (true) {
i++;
System.out.println(Thread.currentThread().getName() + "-------->"
+ i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
设置为守护线程后,当主线程结束后,守护线程并没有把所有的数据输出完就结束了,也即是说守护线程是为用户线程服务的,当用户线程全部结束,守护线程会自动结束
Timer.schedule()
/**
* 关于定时器的应用 作用: 每隔一段固定的时间执行一段代码
*/
public class TimerTest {
public static void main(String[] args) throws ParseException {
// 1.创建定时器
Timer t = new Timer();
// 2.指定定时任务
t.schedule(new LogTimerTask(), new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss SSS").parse("2017-06-29 14:24:00 000"),
10 * 1000);
}
}
// 指定任务
class LogTimerTask extends TimerTask {
@Override
public void run() {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS")
.format(new Date()));
}
}
我是melon,一个10年编程老司机。Q我3474203856。 给melon留言或者说明是看到文章过来的。所有相关技术问题都可以一起寻找到答案。
以上是关于可能是东半球最好的多线程讲义!的主要内容,如果未能解决你的问题,请参考以下文章
东半球最好用的Flask RESTful框架:SinglePage