java_线程基本使用

于 2022-07-17 22:18:30 发布
阅读量137 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44913188/article/details/125590471
版权
本文详细介绍了Java中通过继承Thread类和实现Runnable接口创建线程的区别，包括线程同步、互斥锁、线程终止等概念，并通过示例代码展示了线程的使用和控制。此外，还探讨了线程生命周期、死锁以及线程方法的使用，为理解和应用Java多线程提供了全面的知识。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Thread：

package com.hxh.ThreadUse01;
//通过集成Thread类创建线程
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        cat.start();
        System.out.println("主线程继续执行"+Thread.currentThread().getName());
        for(int i = 10 ;i< 60 ;i++){
            System.out.println("主线程i="+i);
            Thread.sleep(1000);
        }
    }
}

//1.当一个类继承了Thread类，该类就可以当成线程使用
//2.我们会重写run方法写上自己的业余逻辑
//3.Thread类实现了Runnable接口的run方法
class Cat extends Thread{
    int times = 0;
    @Override
    public void run(){
        //重写run方法，写上自己的业务逻辑
        while (true){
            System.out.println("小猫喵喵叫"+(++times)+Thread.currentThread().getName());
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            if(times == 80){
                break;
            }
        }



    }
}

Runnable：

1.java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时候用继承Thread的方法来创建线程就不可能了；

2.java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

package com.hxh.ThreadUse;

public class Thread02 {
    public static void main (String args[]){
        Dog dog = new Dog();
        //dog.start();这里不能使用start方法
        //所以使用这种方法：创建Thread对象，把dog对象（实现Runnable接口)放入Thread
        Thread thread  = new Thread(dog);//这里使用的代理模式
        thread.start();
    }
}
class Dog implements Runnable{//使用Runnale接口创建线程
    int count = 0 ;
    @Override
    public void run(){
     while (true){
         System.out.println("小狗叫"+(++count)+Thread.currentThread().getName());
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         if(count ==  10  ){
             break;
         }
     }
}

}

多线程使用：

package com.hxh.ThreadUse;

import com.hxh.tankgame2.Hero;

public class Thread03 {
    public static void main(String args[]){
        Hello hello = new Hello();
        Thread thread = new Thread(hello);
        Hi hi = new Hi();
        Thread thread1 = new Thread(hi);
        thread.start();
        thread1.start();

    }
}
class Hello implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Hello World"+(++count)+Thread.currentThread().getName());
            if(count == 10 ){
                break;
            }
        }
    }
}
class Hi implements Runnable{
    int count = 0 ;
    @Override
    public void run() {
        while(true){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Hi"+(++count)+Thread.currentThread().getName());
        if(count == 5 ){
            break;
        }
        }
    }
}

继承Thread和实现Runnable接口的区别：

1.从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身实现了Runnable接口，start()->start0();

2.实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

线程终止：

基本说明：

1.当线程完成任务后，会自动退出

2.还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

package com.hxh.ThreadExit;

public class exit {
    public static void main(String[] args) {
    T t =new T();
    t.start();
    //主线程控制T线程终止的时候，修改loop控制变量即可(写一个setloop方法即可)
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        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("Tthread线程运行中");
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

线程方法：

常用方法：

1.setName //设置线程名称，使之与参数name相同

2.getName //返回该线程的名称

3.start //使该线程开始执行；Java虚拟机底层调用该线程的start0()方法，底层会创建一个新的线程，调用run，run就是一个简单的方法调用，不会启动新的线程

4.run //调用线程对象run方法

5.setPriority //更改线程的优先级（线程优先级的范围）

6.getPriority //获取线程的优先级        

7.sleep //在指定的毫秒数内让当前正在执行的线程休眠，线程的静态方法，使当前线程休眠

8.interrupt // 中断线程，但没有真正的结束线程，所以一般用于中断正在休眠线程

9.yield:线程的礼让，让出CPU，让其他线程执行，但是礼让的时间不确定，所以也不一定礼让成功

10.join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

例如：创建一个子线程，每1S输出Hello，输出20次主线程每隔1秒，输出Hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续

用户线程和守护线程：

1.用户线程：也叫工作线程，当线程的任务执行完或者通知方式结束

2.守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

3.常见的守护线程：垃圾回收机制

线程的生命周期


 

线程同步机制：

1.在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性

2.也可以理解为：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

同步具体方法：Synchronized

1.同步代码块

synchronized（对象）{//得到对象的锁才能操作同步代码

//需要被同步的代码；

}

2.Synchronized还可以放在方法声明中，表示整个方法为同步方法

public synchronized void m (String name){

//需要被同步的代码

}

public class SellTicket {
    public static void main(String[] args) {
        /*Sell01 sell01 = new Sell01();
        Sell01 sell02 = new Sell01();
        Sell01 sell03 = new Sell01();
        sell01.start();
        sell02.start();
        sell03.start();*/
        Sell03 sell01 = new Sell03();

        new Thread(sell01).start();
        new Thread(sell01).start();
        new Thread(sell01).start();

    }
}
//实现Runnable接口的方式，使用Synchronized方式实现线程同步
class Sell03 implements Runnable{
    private boolean loop = true;
    int ticketnum = 100;
    public synchronized void sell(){//同步方法，同一时刻只有一个线程能执行该方法
        if(ticketnum <=0){
            System.out.println("售票结束");
            loop =false;
            return;
        }

        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口"+Thread.currentThread().getName()+"卖出一张票"+"剩余票数"+(--ticketnum));
    }

    @Override
    public  void run() {
        while(loop){
        sell();
        }
    }
}

互斥锁：

1.java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性

2.每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象

3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问

4.同步的局限性：导致程序的执行效率要降低

5.同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是同一个对象）

6.同步方法（静态的）的锁为当前类本身

线程的死锁：

基本介绍：多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生

锁的释放：

下面的操作会释放锁：

1.当前线程的同步方法、同步代码块执行结束

2.当前线程在同步代码块、同步方法中遇到break、return

3.当前线程在同步代码块、同步方法中出现了未处理的Error或者Exception,导致异常结束

4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

下面的操作不会释放锁：

1.线程执行同步代码块或同步方法时，程序调用Thread.sleep(),Thread.yield()方法暂停当前线程的执行，不会释放锁

2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（应该尽量避免使用suspend(）和resume()来控制线程 ，方法不再推荐使用）

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值