本文介绍了Java中创建线程的两种方式：继承Thread类和实现Runnable接口，并通过多线程售票问题展示了线程同步的重要性。同步机制包括Synchronized和互斥锁，防止数据竞争。此外，还讨论了线程的生命周期、线程终止以及如何避免线程死锁和正确释放锁。
线程
线程基础
创建线程
继承Tread类
/**
* 演示通过继承Tread类创建线程
*/
public class Thread01 throws InterruptedException {
public static void main(String[] args) {
//创建Cat对象，可以当作线程使用
Cat cat = new Cat();
//启动线程
cat.start();
//说明：当main线程启动一个子线程后，主线程不会阻塞，主线程会继续执行
System.out.println("主线程继续执行，不会阻塞"+Thread.currentThread().getName());
for (int i =0;i<10;i++){
System.out.println("主线程 i="+i);
//让主线程休眠1秒
Thread.sleep(1000);
}
}
}
//继承Thread类
//1. 当一个类继承了Thread类，该类就可以当作线程使用
//2. 我们会重写run方法，写上自己的业务代码
//3. run Thread类 实现了Runable 接口的run方法
class Cat extends Thread{
@Override
public void run(){//重写run方法没写上自己的逻辑
int times = 75;
//该线程每隔一秒，在控制台输出“喵喵喵。我是小猫咪”
while (true) {
System.out.println("喵喵喵。我是小猫咪"+(times++)+"线程名称="+Thread.currentThread().getName());
//让该线程休眠一秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(times==80){
break;//当times等于80时，退出while，这时线程也会退出
}
}
}
}
* 通过jconsole监控
* 为什么是start方法
* 如果直接在主线程中，用Cat对象调用run方法，而不是start方法，实际上就是主线程调用run方法，未开启新线程,此时run方法就是普通的方法，就只能在run方法执行完毕后，才能继续执行下边的代码
* 调用start方法之后
继承Thread类->实现Runable接口
1. java是单继承，在某些情况下类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然是不可能了
2. java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程
实现Runable接口
/**
* @author wilihelmi
* 通过实现Runable接口开发线程
*/
public class Thread02 {
public static void main(String[] args) {
Dog dog = new Dog();
//dog.start();这里不能调用start方法
//创建了Thread对象，把 dog 对象（实现Runable）,把对象放入了Thread
Thread thread = new Thread(dog);
//这里底层使用一种设计模式，代理模式【静态代理】
thread.start();
}
}
//可以将ThreadProxy类当作Thread
//线程代理，模拟了最简单的Thread
class ThreadProxy implements Runnable{
private Runnable targrt = null;
@Override
public void run() {
if(targrt!= null){
targrt.run();
}
}
public ThreadProxy(Runnable targrt){
this.targrt = targrt;
}
public void start(){
start0();//这个方法是真正实现多线程的方法
}
public void start0(){
run();
}
}
//通过实现Runable接口，开发线程
class Dog implements Runnable{
@Override
public void run() {
int count = 0;
while (true){
System.out.println("小狗汪汪叫"+(++count) + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(count==10){
break;
}
}
}
}
多线程售票问题
package threaduse.ticket;
/**
* @author wilihelmi
* 使用多线程，模拟三个窗口售票一百张
*/
public class SellTicket {
public static void main(String[] args) {
SellTicket01 sellTicket01 = new SellTicket01();
SellTicket01 sellTicket02 = new SellTicket01();
SellTicket01 sellTicket03 = new SellTicket01();
sellTicket01.start();//开启售票
sellTicket02.start();//开启售票
sellTicket03.start();//开启售票
}
}
//使用Thread方式
class SellTicket01 extends Thread{
private static int ticketNum = 100;//让多个线程共享 ticketNum
@Override
public void run(){
while (true){
if(ticketNum<=0){
System.out.println("售票结束！");
break;
}
//休眠五十毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 "+Thread.currentThread().getName()+" 售出一张票"
+"剩余票数 "+(--ticketNum));
}
}
}
package threaduse.ticket;
/**
* @author wilihelmi
* 使用多线程，模拟三个窗口售票一百张
*/
public class SellTicket {
public static void main(String[] args) {
SellTicket02 sellTicket02 = new SellTicket02();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
}
}
class SellTicket02 implements Runnable{
private int ticketNum = 100;//让多个线程共享 ticketNum
@Override
public void run(){
while (true){
if(ticketNum<=0){
System.out.println("售票结束！");
break;
}
//休眠五十毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 "+Thread.currentThread().getName()+" 售出一张票"
+"剩余票数 "+(--ticketNum));
}
}
}
线程终止
- 基本说明
- 当线程完成任务后，会自动退出
- 话可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
/** * @author wilihelmi */ public class ThreadExit { public static void main(String[] args) throws InterruptedException { T t = new T(); t.start(); //如果希望主线程能够控制t线程终止，必须修改Loop //让t退出run方法没从而终止t线程->通知方式 Thread.sleep(5000); //通过让主线程休眠十秒，然后再通知子线程退出 t.setLoop(false); } } class T extends Thread{ //设置一个控制变量 private boolean loop = true; @Override public void run(){ while(loop){ try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("运行中......"); } } public void setLoop(boolean loop) { this.loop = loop; } }
线程常用方法
| 方法 | 作用 |
|---|---|
| setName() | 设置线程名称，使之与参数name相同 |
| getName() | 返回该线程名称 |
| start() | 使该线程开始执行，java虚拟机调用该线程的start0()方法 |
| run() | 调用线程对象的run方法 |
| setPriority() | 更改线程优先级 |
| getPriority() | 获取线程优先级 |
| sleep() | 在指定的毫秒数内让当前正在执行的线程休眠（暂时执行） |
| interrupt() | 中断线程 |
package threaduse.method;
/**
* @author wilihelmi
*/
public class ThreadMethod {
public static void main(String[] args) throws InterruptedException {
//测试相关的方法
T t = new T();
//设置线程名称
t.setName("wilihelmi");
//设置线程优先级
t.setPriority(Thread.MIN_PRIORITY);
//启动线程
t.start();
//中断休眠
//主线程打印5个hi,然后就中断子线程休眠
for(int i =0;i<5;i++){
Thread.sleep(1000);
System.out.println("hi~~~"+i);
}
System.out.println(t.getName()+"线程的优先级="+t.getPriority());
//中断子线程的休眠
t.interrupt();
}
}
class T extends Thread{
@Override
public void run() {
while (true) {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "吃饱子~~~" + i);
}
try {
System.out.println(Thread.currentThread().getName() + "休眠中~~~~");
Thread.sleep(20000);
} catch (InterruptedException e) {
//当该线程执行到interrupt方法时，就会catch 一个异常，可以加入自己的业务代码
//InterruptedException 是捕获到一个中断异常
e.printStackTrace();
System.out.println(Thread.currentThread().getName() + "被 interrupt (中断)");
}
}
}
}
| 方法 | 作用 |
|---|---|
| yield() | 线程的礼让，让出cpu，让其他线程执行，但礼让时间不确定，所以也不一定礼让成功 |
| join() | 线程的插队。插队的线程一旦插队成功。则肯定先执行插队线程的所有任务 |
package threaduse.method;
/**
* @author wilihelmi
*/
public class ThreafMethod01 {
public static void main(String[] args) throws InterruptedException {
T1 t1 = new T1();
t1.start();
for (int i =1;i<=20;i++){
Thread.sleep(1000);
System.out.println("主线程吃了"+i+"个包子");
//当主线程吃到五个包子时，先让子线程吃包子
if(i==5){
System.out.println("主线程让子线程先吃~~");
// t1.join();//插队，让子线程先执行完毕
Thread.yield();//礼让
System.out.println("子线程执行完毕");
}
}
}
}
class T1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程吃了" + i + "个包子~~~");
}
}
}
- 用户线程和守护线程
- 用户线程：也叫做工作线程，当线程任务执行完成或通知方式结束
- 守护线程：一般是为工作线程服务的，当所有的工作线程结束，守护线程自动结束
- 常见的守护线程：垃圾回收机制
package threaduse.method;
/**
* @author wilihelmi
*/
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException {
MyDaemonThread myDaemonThread = new MyDaemonThread();
//如果我们希望主线程结束后，子线程自动结束
//只需将子线程设置为守护线程即可
myDaemonThread.setDaemon(true);
myDaemonThread.start();
for(int i = 0;i<5;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("聊天ing~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`~");
}
}
}
线程的生命周期
线程同步机制
同步：在多线程编程中，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
Synchronized
- 同步代码块
synchronized(对象){//得到对象的锁，才能操作同步代码
//需要被同步的代码
} - 同步方法
public synchronized void m(String name){
//需要被同步的代码
}
- 理解：就好像有很多人准备上厕所，只有一个厕所，每个人上厕所前，先把门关上（上锁），完事后出来（解锁），其他的人才可以使用厕所
/**
* @author wilihelmi
* 使用多线程，模拟三个窗口售票一百张,同步
*/
public class SellTicket {
public static void main(String[] args) {
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start();
new Thread(sellTicket03).start();
new Thread(sellTicket03).start();
}
}
//使用同步方法Synchronized实现线程同步
class SellTicket03 implements Runnable{
private int ticketNum = 100;//让多个线程共享 ticketNum
//public synchronized static void m1(){} 锁是加在 SellTicket03.class上的
//静态方法中，实现同步代码块，锁需要加在类上
public synchronized static void m1(){
}
public static void m2(){
synchronized(SellTicket03.class){
//同步代码块
}
}
//说明
//1. 这是一个同步方法
//2. 这时锁在this 对象
//3. 也可以在代码块上写synchronized
public /*synchronized*/ boolean sell(){//同步方法,在同一时刻，只能有一个线程来执行 sell 方法
synchronized(this){
if(ticketNum<=0){
System.out.println(Thread.currentThread().getName()+"售票结束！");
return false;
}
//休眠五十毫秒
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 "+Thread.currentThread().getName()+" 售出一张票"
+"剩余票数 "+(--ticketNum));
return true;
}
}
@Override
public synchronized void run(){
while (true){
if(!sell()){
break;
}
}
}
}
互斥锁
- 基本介绍
- 在java语言中，引入了对象互斥锁的概念，来保证数据操作的完整性
- 每个对象都对应一个可称为”互斥锁“的标记，这个标记用来保证在任一时刻，只能由一个线程访问该对象
- 关键字synchronized来与对象的互斥锁联系，当某个对象用synchronized修饰时，表明该对象在任意时刻只能由一个线程访问
- 同步的局限性：导致程序的执行效率降低
- 同步方法（非静态）的锁可以是this，也可以是其他对象
- 同步方法（静态）的锁为当前类本身
- 注意事项
- 同步方法如果没有使用static修饰：默认锁对象为this
- 如果方法使用static 修饰，默认锁对象：当前类
- 实现的落地步骤
- 需要分析需要上锁的代码
- 选择同步代码块或同步方法
- 需要多个线程的锁对象为同一个即可
线程死锁
- 基本介绍
多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程中一定要避免死锁的发生
package threaduse.Synchronized;
/**
* @author wilihelmi
* 模拟线程死锁
*/
public class DeadLock_ {
public static void main(String[] args) {
//模拟死锁现象
DeadLockDemo A = new DeadLockDemo(true);
A.setName("线程A");
DeadLockDemo B = new DeadLockDemo(false);
B.setName("线程B");
A.start();
B.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 为 T .线程A 就会吸纳得到/持有 o1 对象锁，尝试获取 o2 对象锁 ，
//2. 如果 线程A 得不到 o2 锁，就会Blocked
//3. 如果flag 为 F ，线程B ，就会得到/持有 o2 对象锁 ，尝试获取 o1 对象锁
//4. 如果 线程B 得不到 o1 锁，就会Blocked
if(flag){
//对象互斥锁，使得下方代码成为同步代码
synchronized (o1){//对象互斥锁
System.out.println(Thread.currentThread().getName()+"进入1~~~");
synchronized (o2){
System.out.println(Thread.currentThread().getName()+"进入2~~~~~~~");
}
}
}else {
synchronized (o2){
System.out.println(Thread.currentThread().getName()+"进入3~~~~~~~~~~~~");
synchronized (o1){
System.out.println(Thread.currentThread().getName()+"进入4~~~~~~~~~~~~~~~`~~~");
}
}
}
}
}
释放锁
- 释放锁的操作
- 当前线程的同步方法，同步代码块执行结束
- 当前线程在同步代码块，同步方法中遇到了break,return
- 当前线程在同步代码块，同步方法中出现了未处理的Error或Exception,导致异常结束
- 当前线程在同步代码块，同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
- 不会释放锁的操作
- 线程执行同步代码块或同步方法是，程序调用Thread.sleep(),Thread.yield()方法暂停当前的执行，不会释放锁
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不释放锁
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
