多线程基础和高级
多线程基础
线程:一个顺序的单一的程序执行流程就是一个线程。代码一句一句的有先后顺序的执行。
多线程:多个单一顺序执行的流程并发运行。造成"感官上同时运行"的效果。
并发:
多个线程实际运行是走走停停的。线程调度程序会将CPU运行时间划分为若干个时间片段并
尽可能均匀的分配给每个线程，拿到时间片的线程被CPU执行这段时间。当超时后线程调度
程序会再次分配一个时间片段给一个线程使得CPU执行它。如此反复。由于CPU执行时间在
纳秒级别，我们感觉不到切换线程运行的过程。所以微观上走走停停，宏观上感觉一起运行
的现象成为并发运行!
用途:
- 当出现多个代码片段执行顺序有冲突时，希望它们各干各的时就应当放在不同线程上"同时"运行
- 一个线程可以运行，但是多个线程可以更快时，可以使用多线程运行
创建线程有两种方式
方式一:继承Thread并重写run方法
定义一个线程类，重写run方法，在其中定义线程要执行的任务(希望和其他线程并发执行的任务)。
-
优点: 结构简单，利于匿名内部类形式创建。
-
缺点:1:由于java是单继承的，这会导致继承了Thread就无法再继承其他类去复用方法 2:定义线程的同时重写了run方法，这等于将线程的任务定义在了这个线程中导致线程只能干这件事。重(chong)用性很低。
注:启动该线程要调用该线程的start方法，而不是run方法！！！
public class ThreadDemo1 {
public static void main(String[] args) {
Thread t1 = new Thread1();
Thread t2 = new Thread2();
/*
线程调用完start方法后会纳入到系统的线程调度器程序中被统一管理。
线程调度器会分配时间片段给线程，使得CPU执行该线程这段时间，用完后
线程调度器会再分配一个时间片段给一个线程，如此反复，使得多个线程
都有机会执行一会，做到走走停停，并发运行。
线程第一次被分配到时间后会执行它的run方法开始工作。
*/
t1.start();
t2.start();
}
}
class Thread1 extends Thread{
public void run(){
for (int i = 0; i < 1000; i++) {
System.out.println("1");
}
}
}
class Thread2 extends Thread{
public void run(){
for (int i = 0; i < 1000; i++) {
System.out.println("2");
}
}
}
方式二:实现Runnable接口单独定义线程任务
public class ThreadDemo2 {
public static void main(String[] args) {
//实例化任务
Runnable r1 = new Runnable1();
Runnable r2 = new Runnable2();
//创建线程并指派任务
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
class Runnable1 implements Runnable{
public void run(){
for (int i = 0; i < 1000; i++) {
System.out.println("1");
}
}
}
class Runnable2 implements Runnable{
public void run(){
for (int i = 0; i < 1000; i++) {
System.out.println("2");
}
}
}
匿名内部类形式的线程创建
public static void main(String[] args) {
//第一种方法
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
System.out.println("1");
}
});
//第二种方法
Runnable r2 = () -> {
for (int i = 0; i < 1000; i++) {
System.out.println("2");
}
};
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
java中的代码都是靠线程运行的，执行main方法的线程称为"主线程"。
- java中所有的代码都是靠线程执行的，main方法也不例外。JVM启动后会创建一条线程来执行main方法，该线程的名字叫做"main",所以通常称它为"主线程"。
- 我们自己定义的线程在不指定名字的情况下系统会分配一个名字，格式为"thread-x"(x是一个数)
线程提供了一个静态方法:
-
static Thread currentThread()
该方法可以获取运行这个方法的线程
public class CTDemo { public static void main(String[] args) { //在main方法上定义下面的操作就可以获取运行main方法的线程 //main方法执行完毕则线程结束 Thread main = Thread.currentThread(); System.out.println("主线程："+main); der(); } public static void der(){ //获取运行der线程的方法 Thread der = Thread.currentThread(); System.out.println("der线程："); } }
线程高级
线程API
获取线程相关信息的方法
public static void main(String[] args) {
//获取主线程
Thread main = Thread.currentThread();
//获取线程名字
String name = main.getName();
System.out.println(name);
//获取唯一标识
long id = main.getId();
System.out.println(id);
//获取线程的优先级(1-10,默认为5)
int priority = main.getPriority();
System.out.println(priority);
//该线程是否活着
boolean isAlive = main.isAlive();
System.out.println("是否活着"+isAlive);
//是否为守护线程
boolean isDaemon = main.isDaemon();
System.out.println("是否为守护线程"+isDaemon);
//是否被中断
boolean isInterrupted = main.isInterrupted();
System.out.println("是否中断"+isInterrupted);
}
线程优先级
当一个线程调用start后会纳入到线程调度器中统一管理,线程只能被动的被分配时间片并发运行,而无法主动索取时间片.线程调度器尽可能均匀的将时间片分配给每个线程.
线程有10个优先级,使用整数1-10表示
-
1为最小优先级,10为最高优先级.5为默认值
-
也可以使用Thread提供的常量：MIN_PRIORITY（最低）,NORM_PRIORITY（默认）,MAX_PRIORITY（最高）
-
调整线程的优先级可以最大程度的干涉获取时间片的几率.优先级越高的线程获取时间片的次数越多,反之则越少.
public class priorityDemo { public static void main(String[] args) { Thread min = new Thread(() -> { for (int i = 0; i < 1000; i++) { System.out.println("min"); } }); Thread norm = new Thread(() -> { for (int i = 0; i < 1000; i++) { System.out.println("norm"); } }); Thread max = new Thread(() -> { for (int i = 0; i < 1000; i++) { System.out.println("max"); } }); min.setPriority(Thread.MIN_PRIORITY); max.setPriority(Thread.MAX_PRIORITY); norm.setPriority(Thread.NORM_PRIORITY); min.start(); norm.start(); max.start(); } }
守护线程
守护线程也称为:后台线程
- 守护线程是通过普通线程调用setDaemon(boolean on)方法设置而来的,因此创建上与普通线程无异.
- 守护线程的结束时机上有一点与普通线程不同,即:进程的结束.
- 进程结束:当一个进程中的所有普通线程都结束时,进程就会结束,此时会杀掉所有正在运行的守护线程
通常当我们不关心某个线程的任务什么时候停下来,它可以一直运行,但是程序主要的工作都结束时它应当跟着结束时,这样的任务就适合放在守护线程上执行.比如GC就是在守护线程上运行的.
public static void main(String[] args) {
Thread t1 = new Thread(){
public void run(){
for (int i = 0; i < 5; i++) {
System.out.println("测试一");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
System.out.println("准备");
System.out.println("成功");
}
};
Thread t2 = new Thread(){
public void run(){
while(true) {//设置为死循环
System.out.println("测试二");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
}
};
t1.start();
t2.setDaemon(true);
t2.start();//变为守护线程后程序结束也跟随结束
}
sleep阻塞
线程提供了一个静态方法:
-
static void sleep(long ms)
-
使运行该方法的线程进入阻塞状态指定的毫秒,超时后线程会自动回到RUNNABLE状态等待再次获取时间片并发运行.
public static void main(String[] args) { System.out.println("程序开始了"); try { Thread.sleep(1000);//阻塞一秒钟 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("程序结束了"); } }
sleep方法处理异常:InterruptedException.
当一个线程调用sleep方法处于睡眠阻塞的过程中,该线程的interrupt()方法被调用时,sleep方法会抛出该异常从而打断睡眠阻塞.
public static void main(String[] args) {
Thread t1 = new Thread(){
public void run(){
System.out.println("t1休眠");
try {
Thread.sleep(9999999);
} catch (InterruptedException e) {
//可以输入被强制唤醒后执行的操作
System.out.println("被惊醒");
}
System.out.println("正常醒");
}
};
Thread t2 = new Thread(){
public void run(){
System.out.println("开始执行");
for(int i=0;i<5;i++){
System.out.println("1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
System.out.println("破坏");
System.out.println("成功");
t1.interrupt();//中断lin的睡眠阻塞
}
};
t1.start();
t2.start();
}
多线程并发安全问题
当多个线程并发操作同一临界资源,由于线程切换时机不确定,导致操作临界资源的顺序出现混乱严重时可能导致系统瘫痪.
临界资源:操作该资源的全过程同时只能被单个线程完成.
public class SyncDemo1 {
public static void main(String[] args) {
Table table = new Table();
Thread t1 = new Thread(){
public void run(){
while (true){
int dou = table.getDou();
Thread.yield();
System.out.println(getName()+":"+dou);
}
}
};
Thread t2 = new Thread(){
public void run(){
while (true){
int dou = table.getDou();
Thread.yield();
System.out.println(getName()+":"+dou);
}
}
};
t1.start();
t2.start();
}
}
class Table{
private int dou = 20;//有20个豆子
public int getDou(){
if(dou==0){
throw new RuntimeException("没有豆子了");
}
Thread.yield();//放弃当前时间片回到Running状态
return dou--;
}
}
synchronized关键字
synchronized有两种使用方式
- 在方法上修饰,此时该方法变为一个同步方法
- 同步块,可以更准确的锁定需要排队的代码片段
同步方法
当一个方法使用synchronized修饰后,这个方法称为"同步方法",即:多个线程不能同时 在方法内部执行.只能有先后顺序的一个一个进行. 将并发操作同一临界资源的过程改为同步执行就可以有效的解决并发安全问题.
在成员方法上使用synchronized时，同步监视器对象就是this，不可更改
//在getdou（）方法上加上synchronized后相当于给线程上了一把锁，需要等线程操作完成后才会继续下一次线程，解决了线程的并发问题，但相应的会降低效率。
class Table{
private int dou = 20;//有20个豆子
public synchronized int getDou(){
if(dou==0){
throw new RuntimeException("没有豆子了");
}
Thread.yield();//放弃当前时间片回到Running状态
return dou--;
}
}
同步块
有效的缩小同步范围可以在保证并发安全的前提下尽可能的提高并发效率.同步块可以更准确的控制需要多个线程排队执行的代码片段.
同步执行和异步执行：这两种都可以说是多线程的执行。
同步执行：多个线程执行的过程中出现了先后顺序
异步执行：多个线程各执行各的。之间没有顺序
语法: synchronized (同步监视器对象) {需要多线程同步执行的代码片段}
public class SyncDemo2 {
public static void main(String[] args) {
Shop s = new Shop();
Thread t1 = new Thread("张三"){
public void run(){
s.buy();
}
};
Thread t2 = new Thread("李四"){
public void run(){
s.buy();
}
};
t1.start();
t2.start();
}
}
class Shop{
public void buy(){
try {
Thread t = Thread.currentThread();//获取运行方法的线程
System.out.println(t.getName()+"正在买东西");
Thread.sleep(5000);
synchronized (this) {
//这个对象可以是java中任何引用类型的实例，只要保证多个需要排队
//执行该同步块中代码的线程看到的该对象是"同一个"即可
//将需要单独执行的代码写入同步块
System.out.println(t.getName()+"正在测试");
Thread.sleep(5000);
}
System.out.println(t.getName()+"买完离开");
} catch (InterruptedException e) {
}
}
}
在静态方法上使用synchronized
当在静态方法上使用synchronized后,该方法是一个同步方法.由于静态方法所属类,所以一定具有同步效果.
静态方法使用的同步监视器对象为当前类的类对象(Class的实例).
注:类对象会在后期反射知识点介绍.
public class SyncDemo3 {
public static void main(String[] args) {
Thread t1 = new Thread(){
public void run(){
Boo.dosome();
}
};
Thread t2 = new Thread(){
public void run(){
Boo.dosome();
}
};
t1.start();
t2.start();
}
}
class Boo{
/**
* synchronized在静态方法上使用是，指定的同步监视器对象为当前类的类对象。
* 即:Class实例。
* 在JVM中，每个被加载的类都有且只有一个Class的实例与之对应
*/
public synchronized static void dosome(){
Thread t = Thread.currentThread();
try {
System.out.println(t.getName() + ":正在执行dosome方法...");
Thread.sleep(5000);
System.out.println(t.getName() + ":执行dosome方法完毕!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
静态方法中使用同步块时,指定的锁对象通常也是当前类的类对象
class Boo{
public static void dosome(){
/*
静态方法中使用同步块时，指定同步监视器对象通常还是用当前类的类对象
获取方式为:类名.class
*/
synchronized (Boo.class) {
Thread t = Thread.currentThread();
try {
System.out.println(t.getName() + ":正在执行dosome方法...");
Thread.sleep(5000);
System.out.println(t.getName() + ":执行dosome方法完毕!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
互斥锁
当多个线程执行不同的代码片段,但是这些代码片段之间不能同时运行时就要设置为互斥的.
使用synchronized锁定多个代码片段,并且指定的同步监视器是同一个时,这些代码片段之间就是互斥的.即:多个线程不能同时访问这些方法。
public class SyncDemo4 {
public static void main(String[] args) {
Foo foo = new Foo();
Thread t1 = new Thread(){
public void run(){
foo.methodA();
}
};
Thread t2 = new Thread(){
public void run(){
foo.methodB();
}
};
t1.start();
t2.start();
}
}
class Foo{
public synchronized void methodA(){
Thread t = Thread.currentThread();
try {
System.out.println(t.getName()+":正在执行A方法...");
Thread.sleep(5000);
System.out.println(t.getName()+":执行A方法完毕!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void methodB(){
Thread t = Thread.currentThread();
try {
System.out.println(t.getName()+":正在执行B方法...");
Thread.sleep(5000);
System.out.println(t.getName()+":执行B方法完毕!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
注意：只有锁对象相同并且都添加了synchronized才会产生互斥现象。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
