线程
示意图
相关概念
程序(program)
是为完成特定任务、用某种语言编写的一组指令的集合。简单的说:就是我们写的代码
进程
- 进程是指运行中的程序,比如我们使用QQ,就启动了一个进程,操作系统就会为该进程分配内存空间。当我们使用迅雷,又启动了一个进程,操作系统将为迅雷分配新的内存空间。
- 进程是程序的一次执行过程,或是正在运行的一个程序。是动态过程:有它自身的
线程
- 线程由进程创建的,是进程的一个实体
- 一个进程可以拥有多个线程
单线程
同一个时刻,只允许执行一个线程
多线程
同一个时刻,可以执行多个线程,比如:一个qq进程,可以同时打开多个聊天窗口,一个迅雷进程,可以同时下载多个文件
并发
同一个时刻,多个任务交替执行,造成一种“貌似同时”的错觉,简单的说,单核cpu实现的多任务就是并发。
并行
同一个时刻,多个任务同时执行。多核cpu可以实现并行。
用户线程
也叫工作线程,当线程的任务执行完或通知方式结束
守护线程
一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束常见的守护线程:垃圾回收机制
用法
myDaemonThread.setDaemon(true);
基本语法
创建线程
-
继承Thread类,重写run方法
-
应用案例
package Thread; public class txt01 { public static void main(String[] args) { //1。当一个类继承了 Thread 类,该类就可以当做线程使用 ///2.我们会重写 run方法,写上自己的业务代码 //3. run Thread 类实现了 Runnable 接口的run方法 /* Override public void run() { if (target != null) { target.run(); } } */ // 请编写程序,开启一个线程,该线程每隔1秒。 // 在控制台输出“我是小猫咪” // 对上题改进:当输出80次瞄噬,我是小猫咪,结束该线程 //创建Cat对象,可以当做线程使用 Cat cat = new Cat(); cat.start();//启动线程->最终会执行cat的run方法 // cat.run() ;//run方法就是一个普通的方法,没有真正的启动一个线程,| // 说明:当main线程启动一个子线程Thread-0, // 主线程不会阻塞,会继续执行门这时主线程和子线程是交替执行.. // (1) // public synchronized void start() { // start0(); // } // (2)start0()是本地方法,是JVM调用,底层是c/c++实现 // 真正实现多线程的效果,是start0(),而不是 run System.out.println("主线程继续执行" +Thread.currentThread(). getName());//名字main for(int i = 0; i < 60;i++) { System.out.println("主线程i="+i);//让主线程休眠 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Cat extends Thread{ @Override public void run() { for (int i = 0; i < 9; i++) { System.out.println("我是小猫咪"+Thread.currentThread().getName()); } } }
-
-
实现Runnable接口,重写run方法
-
应用案例
package Thread; public class txt02 { public static void main(String[] args) { // java是单继承的,在某些情况下一个类可能已经继承了某个父类, // 这时在用继承Thread类方法来创建线程显然不可能了。 // java设计者们提供了另外一个方式创建线程, // 就是通过实现Runnable接口来创建线程 // 请编写程序该程序可以每隔1秒。在控制台输出“hi!”, // 当输出10次后,自动退出。请使用实现Runnable接口的方式实现。 person p1=new person(); Thread t=new Thread(p1); t.start(); } } class person implements Runnable{ @Override public void run() { for (int i = 0; i < 8; i++) { System.out.println("hi"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
-
继承Thread vs 实现Runnable的区别
- 从java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
- 实现Runnable接口方式更加适合多个线程共享一个资源的情况,并且避免了单继承的限制
线程终止
- 当线程完成任务后,会自动退出。
- 还可以通过使用变量来控制run方法退出的方式停止线程,即通知方式
应用案例
package Thread;
public class txt03 {
public static void main(String[] args) {
// 需求:启动一个线程t,要求在main线程中去停止线程t,请编程实现.
M m = new M();
m.start();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
m.setLoop(false);
}
}
class M extends Thread{
//设置一个控制变量,用来终止程序的运行
boolean loop=true;
public void setLoop(boolean loop) { this.loop = loop; }
@Override
public void run() {
while (loop) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("i");
}
}
}
常用方法
- setName //设置线程名称,使之与参数name 相同
- getName //返回该线程的名称
- start //使该线程开始执行;Java虚拟机底层调用该线程的start0方法
- run //调用线程对象 run方法;
- setPriority //更改线程的优先级
- getPriority //获取线程的优先级
- sleep //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
- interrupt //中断线程
注意事项
-
start 底层会创建新的线程,调用run, run 就是一个简单的方法调用,不会启动新线程
-
线程优先级的范围
-
interrupt,中断线程,但并没有真正的结束线程。所以一般用于中断正在休眠线程. sleep:线程的静态方法,使当前线程休眠
-
yield:线程的礼让。让出cpu,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功
-
join: 线程的插队。插队的线程一旦插队成功,则肯定先执行完插入的线程所有的任务
插队练习
package Thread; public class txt04 { public static void main(String[] args) { // 主线程每隔1s,输出hi,一共10次当输出到hi 5时, // 启动一个子线程(要求实现Runnable),每隔1s输出hello, // 等该线程输出10次hello后,退出 // 主线程继续输出hi,直到主线程退出. N n = new N(); for (int i = 0; i < 10; i++) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("hi"); if (i==5){ Thread t=new Thread(n); t.start(); try { t.join(); } catch (InterruptedException e) { e.printStackTrace(); } } } System.out.println("主线程结束......"); } } class N implements Runnable{ @Override public void run() { for (int i = 0; i < 10; i++) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("hello"); } System.out.println("子线程结束..."); } }
线程同步机制
- 在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何时刻,最多有一个线程访问,以保证数据的完整性。
- 也可以这里理解:线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作.
使用方法
-
同步代码块
synchronized(对象){//得到对象的锁,才能操作同步代码
//需要被同步代码;
}
-
synchronized还可以放在方法声明中,表示整个方法-为同步方法
public synchronized void m (String name){
//需要被同步的代码
}
线程的状态
分类
- NEW 尚未启动的线程处于此状态。
- RUNNABLE 在Java虚拟机中执行的线程处于此状态。
- BLOCKED 被阻塞等待监视器锁定的线程处于此状态。
- WA工TING 正在等待另一个线程执行特定动作的线程处于此状态。
- TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
- TERMINATED 已退出的线程处于此状态。
互斥锁
基本介绍
- Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。
- 每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问
- 同步的局限性:导致程序的执行效率要降低
- 同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
- 同步方法(静态的)的锁为当前类本身。
注意细节
-
同步方法如果没有使用static修饰:默认锁对象为this
-
如果方法使用static修饰,默认锁对象:当前类.class
-
实现的落地步骤:
需要先分析上锁的代码选择同步代码块或同步方法
要求多个线程的锁对象为同一个即可
线程的死锁
多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,在编程是一定要避免死锁的发生.
释放锁
释放锁的操作
-
当前线程的同步方法、同步代码块执行结束
案例:上厕所,完事出来
-
当前线程在同步代码块、同步方法中遇到break、return。
案例:没有正常的完事,经理叫他修改bug,不得已出来
-
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
案例:没有正常的完事,发现忘带纸,不得已出来
-
当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。
不会释放锁的操作
-
线程执行同步代码块或同步方法时,程序调用Thread.sleep().Thread.yield(0方法暂停当前线程的执行,不会释放锁
案例:上厕所,太困了,在坑位上眯了一会
-
线程执行同步代码块时,其他线程调用了该线程的suspend(方法将该线程挂起,该线程不会释放锁。
提示:应尽量避免使用suspend (0和resume()来控制线程,方法不再推荐使用
章节练习题
package Thread;
public class fwork01 {
public static void main(String[] args) {
//多线程同步机制卖票
employ e = new employ();
new Thread(e).start();
new Thread(e).start();
new Thread(e).start();
}
}
class employ implements Runnable{
public static int tickets=100;
static boolean loop=true;
public synchronized void sell(){
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
tickets--;
System.out.println("售卖出一张票" + Thread.currentThread().getName() + "还剩" + tickets + "张票");
}else{
System.out.println("售票结束");
loop=false;
return;
}
}
@Override
public void run() {
while (loop) {
sell();
}
}
}
package Thread;
import java.util.Scanner;
public class work02 {
public static void main(String[] args) {
//第一题
// (1)在main方法中启动两个线程
// (2)第1个线程循环随机打印100以内的整数
// (3)直到第2个线程从键盘读取了“Q”命令。
A a=new A();
B b=new B(a);
a.start();
b.start();
}
}
class A extends Thread{
boolean loop=true;
@Override
public void run() {
while(loop){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Math.random()*100+1);
}
}
}
class B extends Thread{
A a;
public B(A a){
this.a=a;
}
@Override
public void run() {
while(true){
Scanner input=new Scanner(System.in);
System.out.println("请输入停止指令:");
String cc=input.next();
char c=cc.charAt(0);
if (c=='Q'){
a.loop=false;
break;
}
}
}
}