Java_线程基础 - 实践
程序(program):
是为完成特定任务,用某种语言编写的一组指令的集合
进程:
1.进程是指运行中的程序,比如我们使用QQ,就启动了一个进程,操作系统会为该进程分配内存空间,当我们使用迅雷,就又启动了一个进程,操作系统将为迅雷分配新的内存空间
2.进程是程序的一次执行过程,或是正在运行的一个程序,是动态过程:有它自身的产生,存在和消亡的过程
线程:
1.线程由进程创建的,是进程的一个实体
2.一个进程可以拥有多个线程
其他相关概念:
1.单线程:同一个时刻,只允许执行一个线程
2.多线程:同一个时刻,可以执行多个线程,比如:一个QQ进程,可以同时打开多个聊天窗口,一个迅雷进程,可以同时下载多个文件
3.并发:同一个时刻,多个任务交替执行,造成一种"貌似同时"的错觉,简单地说,单核CPU实现的多任务就是并发
4.并行:同一个时刻,多个任务同时执行,多核CPU可以实现并行
package com.thread_;
//查看CPU核心数
public class CpuNum {
public static void main(String[] args) {
Runtime runtime = Runtime.getRuntime();
int cpuNums = runtime.availableProcessors();
System.out.println("当前cpu个数=" + cpuNums);
}
}线程基本使用:
创建线程的两种方式:
1.继承Thread类,重写run 方法
2.实现Runnable接口,重写run 方法
线程应用案例1 --继承Thread类
1)编写程序,开启一个线程,该线程每隔一秒,在控制台输出"喵喵喵"
2)改进:当输出80次"喵喵喵"时,结束该线程
3)使用JConsole监控线程执行情况,并画出程序示意图
package com.thread_.ThreadUse;
//演示通过继承Thread类创建线程
public class ThreadUse {
public static void main(String[] args) throws InterruptedException{
//创建Cat 对象,可以当做线程使用了
new Cat().start();//启动线程
//当main线程启动一个子线程Thread-0,主线程不会阻塞,会继续执行
System.out.println("主线程继续执行" + Thread.currentThread().getName());
for (int i = 0; i < 10; i++) {
System.out.println("主线程i=" + i);
//让主线程休眠
Thread.sleep(1000);
}
}
}
//当一个类继承了Thread 类,该类就可以当作线程使用
//我们会重写run() ,在这里写上自己的业务代码
//run()是Thread 类实现了Runnable 接口的方法
/*
@Override
public void run() {
if (target != null) {
target.run();
}
}
*/
class Cat extends Thread{
int times = 0; //统计循环次数
@Override
public void run() { //在这里重写run() 实现自己的业务逻辑
while(true) {
System.out.println("喵喵喵" + times + "线程名" + Thread.currentThread().getName());
times++;
//让该线程休眠一秒钟
//Thread.sleep(1000); 直接使用会抛出异常,所以需要try - catch(ctrl + alt + t)
try {
Thread.sleep(1000); //毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
if (times >= 80){
break; //到80时线程退出
}
}
}
}
*main线程与Thread线程交替执行
JConsole查看线程:
程序运行时在终端输入JConsle -找到执行的程序并双击 -线程
*主线程结束时,如果有子线程还在继续运行,并不会造成整个程序的结束
为什么是start()而不是run():
run() 就是一个普通的方法,调用它并没有真正的启动一个线程
验证:
new Cat().run();//启动线程
可以看到,调用run() 执行程序时,线程名为main
可知,run() 就是一个普通方法,没有真正启动一个线程,就会有线程阻塞的问题,即要先把run() 执行完毕,才继续向下执行,就不是多线程了(相当于是单线程,串行化的执行)
start()解读:
new Cat().start();//启动线程
/*
1.public synchronized void start() {
start0();
}
2.private native void start0();
底层,是一个本地方法(native),由JVM调用,底层是由 C/C++实现
真正实现多线程的效果,是start0(),而不是run()
*/
线程应用案例 --实现Runnable接口
说明:
1.java是单继承的,在某些情况下一个类可能已经继承了某个父类,这时再用继承Thread类方法来创建线程显然不可能了
2.java设计者们提供了另一个方式来创建线程,就是通过实现Runnable接口来创建线程
应用案例:
编写程序,该程序可以每隔一秒,在控制台输出"泥嚎",当输出10次后,自动退出,请使用实现Runnable接口的方式实现(静态代理)
package com.thread_.ThreadUse;
public class Thread02 {
public static void main(String[] args){
//new Dog().start() 这里不能调start(),因为Runnable接口没有
//需要创建Thread对象,然后把Dog放进去
new Thread(new Dog()).start();
//这里底层使用了代理模式(静态代理)
}
}
class Dog implements Runnable{ //通过实现Runnable接口,开发线程类
int count = 0;
@Override
public void run(){ //普通方法.直接调用这个方法并没有启动多线程
while(true){
System.out.println("泥嚎" + (++count) + "线程名称为" + Thread.currentThread().getName());
if(count == 10){
break;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}代码模拟实现Runnable接口开发线程的机制:
package com.thread_.ThreadUse;
public class Thread02 {
public static void main(String[] args){
new ThreadProxy(new Dog()).start();
//这里底层使用了代理模式(静态代理)
}
}
//代码模拟实现Runnable接口开发线程的机制:
class ThreadProxy implements Runnable{ //可以把ThreadProxy(线程代理)类当作Thread
private Runnable target = null; //属性,类型是Runnable
@Override
public void run(){
if(target != null){
target.run(); //动态绑定,绑到Dog类中的run() Dog实现了Runnable接口,所以它可以赋到Runnable类型的target
}
}
public ThreadProxy(Runnable target) {
this.target = target;
}
public void start(){
start0(); //真正实现多线程的方法
}
public void start0(){
run();
}
}
class Dog implements Runnable{ //通过实现Runnable接口,开发线程类
int count = 0;
@Override
public void run(){ //普通方法.直接调用这个方法并没有启动多线程
while(true){
System.out.println("泥嚎" + (++count) + "线程名称为" + Thread.currentThread().getName());
if(count == 10){
break;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}线程使用案例 --多线程执行
编写一个程序,创建两个线程,一个线程每隔一秒输出"hello,world",输出10次,退出,一个线程每隔一秒输出"hi",输出5次,退出
package com.thread_.ThreadUse;
public class Thread03 {
public static void main(String[] args) {
new Hello().start();
new Thread(new hi()).start();
}
}
class Hello extends Thread{
private int count;
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("hello,world" + (count++));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class hi implements Runnable{
private int count;
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("hi" + (count++));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}继承Thread和实现Runnable的区别:
1.从Java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
2.实现Runnable接口方式更加适合多个线程共享一个资源的情况,并且避免了单继承的限制,建议使用Runnable
3.售票系统:模拟三个售票窗口售票100张,分别使用继承Thread 和实现Runnable方式并分析问题
package com.thread_.ThreadUse;
//使用多线程模拟三个窗口同时售票100张
public class SellTicket {
public static void main(String[] args) {
new SellTicket01().start();
new SellTicket01().start();
new SellTicket01().start();
}
}
//继承Thread
class SellTicket01 extends Thread{
private static int ticketNum = 100; //使用static让多个线程共享ticketNum
@Override
public void run() {
while(true){
if(ticketNum <= 0){
System.out.println("售票结束.....");
break;
}
//休眠50ms
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//用线程模拟售票窗口
System.out.println("窗口" + Thread.currentThread().getName() +
"售出一张票" + "剩余票数=" + (--ticketNum));
}
}
}
这里我们会出现票数超卖的现象 --线程终止
基本说明:
1.当线程完成任务后,会自动退出
2.还可以通过使用变量来控制run() 退出的方式停止线程,即通知方式
需求:启动一个线程t ,要求在main线程中去停止线程t
package com.thread_.exit_;
public class ThreadExit_ {
public static void main(String[] args) throws InterruptedException{
T t1 = new T();
t1.start();
//如果希望main线程去控制t1 线程的终止,就必须可以修改loop
//让t1退出run() 从而终止t1线程 ->通知方式
//让主线程休眠10s,再去通知t1退出
System.out.println("主线程休眠10s");
Thread.sleep(10000);
t1.setLoop(false);
}
}
class T extends Thread{
private int count = 0;
//设置一个控制变量
private boolean loop = true;
@Override
public void run() {
while (loop){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("T 运行中......." + (++count));
}
}
public void setLoop(boolean loop) { //修改loop去控制循环退出
this.loop = loop;
}
}线程常用方法:
第一组:
1.setName:设置线程名称,使其与参数name相同
2.getName:返回该线程的名称
3.start:使该线程开始执行;java虚拟机底层调用该线程的start0 方法
4.run:调用线程对象的run();
5.setPriority:更改线程的优先级
6.getPriority:获取线程的优先级
7.sleep:在指定的毫秒数内让当前正在执行到线程休眠(暂停执行)
8.interrupt:中断线程(不是停止/终止线程)
注意事项和细节:
1.start底层会创建新的线程,调用run() 时,run()就是一个简单的方法调用,不会启动新线程
2.线程优先级的范围 1-5-10
3.interrupt,中断线程,但并没有真正的结束线程,所以一般用于中断正在休眠的进程(把它唤醒)
可以理解为这个:
4.sleep:线程的静态方法,使当前线程休眠
package com.thread_.ThreadMethod;
public class ThreadMethod01 {
public static void main(String[] args) throws InterruptedException{
//测试相关方法
T t = new T();
t.setName("泥嚎"); //设置线程名称
t.setPriority(Thread.MIN_PRIORITY); //设置线程优先级,这里设置为最小值1
t.start();
System.out.println(t.getName()); //获取线程名称
//主线程打印五个hi ,然后就中断子线程的休眠
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("hi" + i);
}
System.out.println(t.getName() + "线程的优先级" + t.getPriority()); //输出1
t.interrupt(); //提前结束"泥嚎"线程的休眠(中断20s的休眠),继续执行100次下面的吃包子语句
}
}
class T extends Thread{ //自定义线程类
@Override
public void run() {
while (true) {
for (int i = 0; i < 100; i++) {
//Thread.currentThread().getName()获取当前线程名称
System.out.println(Thread.currentThread().getName() + "吃包子......");
}
try {
System.out.println(Thread.currentThread().getName() + "休眠中......");
Thread.sleep(20000);
} catch (InterruptedException e) {
//当该线程执行到一个interrupt 方法时,就会catch一个异常,可以加入自己的业务代码
//InterruptedException 是捕获到一个终止异常
System.out.println(Thread.currentThread().getName() + "被interrupt了");
}
}
}
}第二组:
1.yield:线程的礼让,让出CPU,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功
2.join:线程的插队,插队的线程一单插队成功,则肯定先执行完插入线程的所有任务
案例:创建一个子线程,每隔1s 输出hello,输出20次,主线程每隔一秒,输出hi,输出20次.要求:两个线程同时执行,当主线程输出5次后,就让子线程运行完毕,主线程再继续
package com.thread_.ThreadMethod;
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException{
T2 t2 = new T2();
t2.start();
for (int i = 0; i <= 20 ; i++) {
Thread.sleep(1000);
System.out.println("主线程吃了" + i + "个包子...");
if(i == 5){
System.out.println("主线程让子线程先吃.....");
//t2.join(); //这里相当于让t2(子线程)先执行,线程插队,一定会成功
Thread.yield(); //礼让,不一定成功
System.out.println("子线程吃完了,主线程接着吃......");
}
}
}
}
class T2 extends Thread{
@Override
public void run() {
for (int i = 1; i <= 20; i++) {
try {
Thread.sleep(1000); //休眠1s
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程吃了" + i + "个包子.....");
}
}
}要求:
1.主线程每隔1s,输出hi,一共十次
2.当输出到hi 5时,启动一个子线程(要求实现Runnable),每隔1s输出hello,等该线程输出10次后,退出
3.主线程继续输出hi,直到主线程退出
package com.thread_.ThreadMethod;
public class ThreadMethodExercise {
public static void main(String[] args) throws InterruptedException{
for (int i = 0; i < 10; i++) {
System.out.println("hi " + (i + 1));
Thread.sleep(1000);
if(i == 4){
Hello hello = new Hello();
Thread thread = new Thread(hello);
thread.start();
thread.join();
}
}
System.out.println("主线程结束.....");
}
}
class Hello implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("hello " + (i + 1));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("子线程结束.....");
}
}线程常用方法 --用户线程和守护线程
1.用户线程:也叫工作线程,当线程的任务执行完或通知方式结束
2.守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束
3.常见的守护线程:垃圾回收机制
package com.thread_.ThreadMethod;
public class ThreadMethod03 {
public static void main(String[] args) throws InterruptedException{
MyDaemonThread myDaemonThread = new MyDaemonThread();
//如果我们希望main线程结束后,子线程可以自动结束
//将子线程设置为守护线程即可
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for (int i = 1; i <= 10; i++) {
System.out.println("宝强在辛苦工作......");
Thread.sleep(1000);
}
}
}
class MyDaemonThread extends Thread{
@Override
public void run() {
for (;;){ //无限循环
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("马蓉和宋喆快乐聊天......");
}
}
}线程的生命周期(线程七大状态):
JDK中用Thread.State枚举表示了线程的几种状态:
查看线程状态:
package com.thread_.state_;
public class ThreadState_ {
public static void main(String[] args) throws InterruptedException{
T t = new T();
System.out.println(t.getName() + " 状态 " + t.getState());
t.start();
while (Thread.State.TERMINATED != t.getState()) {
System.out.println(t.getName() + " 状态 " + t.getState());
Thread.sleep(1000);
}
System.out.println(t.getName() + " 状态 " + t.getState());
}
}
class T extends Thread{
@Override
public void run() {
while (true){
for (int i = 0; i < 10; i++) {
System.out.println("hi" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
}
}
线程的同步(Synchronized):
线程同步机制:
1.在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性
2.也可以这样理解:线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才可以对该内存地址进行操作
同步具体方法:
1.同步代码块
synchronized (对象) { //得到对象的锁,才能操作同步代码
//需要被同步的代码
}
2.synchronized还可以放在方法声明中,表示整个方法为同步方法
public synchronized void m(String name){
//需要被同步的代码
}
使用synchronized解决上面的售票问题:
package com.thread_.synchronized_;
public class syn01 {
public static void main(String[] args) {
SellTicket01 sellTicket01 = new SellTicket01();
Thread thread = new Thread(sellTicket01);
Thread thread1 = new Thread(sellTicket01);
Thread thread2 = new Thread(sellTicket01);
thread.start();
thread1.start();
thread2.start();
}
}
//使用同步方法synchronized实现线程同步
class SellTicket01 implements Runnable{
private boolean loop = true; //控制循环
private static int ticketNum = 100; //使用static让多个线程共享ticketNum
public synchronized void sell(){ //同步方法,在同一时刻只能由一个线程执行sell()
if(ticketNum <= 0){
System.out.println("售票结束.....");
loop = false;
return;
}
//休眠100ms
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//用线程模拟售票窗口
System.out.println("窗口" + Thread.currentThread().getName() +
"售出一张票" + "剩余票数=" + (--ticketNum));
}
@Override
public void run() {
while(loop){
sell(); //是一个同步方法,同一时刻只能由一个线程执行
}
}
}互斥锁:
基本介绍:
1.Java在Java语言中引入了对象互斥锁的概念,来保证共享数据操作的完整性
2.每个对象都对应于一个可称为"互斥锁"的标记,这个标记用来保证在任一时刻,只能由一个线程访问该对象
3.关键字synchronized 来与对象的互斥锁联系,当某个对象用synchronized 修饰时,表明该对象在任一时刻只能由一个线程访问
4.同步的局限性:导致程序的执行效率要降低
5.同步方法(非静态的)的锁可以是this(当前对象),也可以是其他对象(要求是同一个对象)
6.同步方法(静态的)的锁为当前类本身
package com.thread_.synchronized_;
public class syn01 {
public static void main(String[] args) {
SellTicket01 sellTicket01 = new SellTicket01();
Thread thread = new Thread(sellTicket01);
Thread thread1 = new Thread(sellTicket01);
Thread thread2 = new Thread(sellTicket01);
thread.start();
thread1.start();
thread2.start();
}
}
//使用同步方法synchronized实现线程同步
class SellTicket01 implements Runnable{
private boolean loop = true; //控制循环
private static int ticketNum = 100; //使用static让多个线程共享ticketNum
Object object = new Object();
//同步方法(静态的)的锁为当前类本身
//解读:
//public synchronized static void m1(){} 锁是加在SellTicket01.class
//如果在静态方法中要实现一个同步代码块,需要用类名.class作为锁
public synchronized static void m1(){
}
public static void m2(){
synchronized (SellTicket01.class) { //不可以写成synchronized (new SellTicket01()),会导致每次都创建新对象
System.out.println("m2.....");
}
}
//1.public synchronized void sell() 就是一个同步方法
//2.这时,锁在this对象
//3.也可以在代码块上写synchronized,即同步代码块
public /*synchronized*/ void sell(){ //同步方法,在同一时刻只能由一个线程执行sell()
synchronized (/*this*/ object){
if(ticketNum <= 0){
System.out.println("售票结束.....");
loop = false;
return;
}
//休眠100ms
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//用线程模拟售票窗口
System.out.println("窗口" + Thread.currentThread().getName() +
"售出一张票" + "剩余票数=" + (--ticketNum));
}
}
@Override
public void run() {
while(loop){
sell(); //是一个同步方法,同一时刻只能由一个线程执行
}
}
}*m1()和m2()用法等价,sell()同理
注意事项和细节:
1.同步方法如果没有使用static修饰,默认锁对象为this
2.如果方法使用了static修饰,默认锁对象:当前类.class
3.实现的落地步骤:
需要先分析上锁的代码
选择同步代码块(推荐)或同步方法,同步的代码越少,效率越高
要求多个线程的锁对象为同一个即可
线程的死锁:
基本介绍:
多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,在编程中一定要避免死锁的发生
演示:
package com.thread_.synchronized_;
//模拟线程死锁
public class DeadLock_ {
public static void main(String[] args) {
//模拟死锁现象
new DeadLockDemo(true).start();
new DeadLockDemo(false).start();
}
}
class DeadLockDemo extends Thread{
static Object o1 = new Object(); //保证多线程,共享一个对象,这里使用static
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag){
this.flag = flag;
}
@Override
public void run() {
//下面业务逻辑的分析
//1.如果flag为真,线程A就会先持有(得到)o1对象锁,然后尝试去获取o2对象锁
//2.如果线程A得不到o2对象锁,就会Blocked
//3.如果flag为假,线程B就会先持有(得到)o2对象锁,然后尝试去获取o1对象锁
//4.如果线程B得不到o1对象锁,就会Blocked
if(flag){
synchronized (o1){ //互斥锁,下面就是同步代码
System.out.println(Thread.currentThread().getName() + "进入1");
synchronized (o2){ //这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + "进入2");
}
}
}else{
synchronized (o2){
System.out.println(Thread.currentThread().getName() + "进入3");
synchronized (o1){ //这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + "进入4");
}
}
}
}
}释放锁:
下面操作会释放锁:
1.当前线程的同步方法,同步代码块执行结束
2.当前线程在同步代码块,同步方法中遇到break,return
3.当前线程在同步代码块,同步方法中出现了未处理的Error或Exception,导致异常结束
4.当前线程在同步代码块,同步方法中执行了线程对象的wait() 方法,当前线程暂停,并释放锁
下面的操作不会释放锁:
1.线程执行同步代码块或同步方法时,程序调用Thread.sleep() ,Thread.yield()方法暂停当前线程的执行,不会释放锁
2.线程执行同步代码块时,其他线程调用了该线程的suspend() 将线程挂起,该线程不会释放锁,提示:应尽量避免使用suspend() 和resume() 来控制线程,不推荐使用
浙公网安备 33010602011771号