JAVA--线程

最新推荐文章于 2022-12-28 15:02:12 发布

OnlyTyou

最新推荐文章于 2022-12-28 15:02:12 发布

阅读量561

点赞数

分类专栏： ACM->JAVA 文章标签：线程

本文链接：https://blog.csdn.net/u013514722/article/details/49850493

版权

ACM->JAVA 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

自定义线程

方式：

方式一： 1.自定义一个类继承Thread方法
        2.重写Thread类的run方法，把自定义线程的任务代码写在run方法中
        3.创建Thread的子类对象，并且调用start方法开启线程。
        （线程一旦开启，就会直接调用run方法，不可直接在main中调用）
方式二： 1.自定义一个类实现Runnable接口；
        2.实现Runable接口的run方法，把自定义线程的任务写在run方法上。
        3.创建Runable实现类对象。
        4.创建Thread类对象，并把Runnable的实现类对象作为实参传递。
        5.调用Thread对象的start方法开启线程。

线程的状态：

1.创建：新创建了一个线程对象。
2.可运行：线程对象创建后，其他线程调用了该对象的start()方法。该状
    态的线程位于可运行线程池中，变得可运行，等待获取cpu的执行权。
3.运行：就绪状态的线程获取了CPU执行权，执行程序代码。
4.阻临时塞: 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止
    运行。直到线程进入就绪状态，才有机会转到运行状态。
5.死亡：线程执行完它的任务时。

常用线程的方法：

1.Thread(String name)     初始化线程的名字
 2.getName()             返回线程的名字
 3.setName(String name)    设置线程对象名
 4.sleep(int Millis)                 线程睡眠指定的毫秒数。
 5.getPriority()  返回当前线程对象的优先级 默认线程的优先级是5
 6.setPriority(int newPriority) 设置线程的优先级    
     虽然设置了线程的优先级，但是具体的实现取决于底层的操作系统的
     实现（最大的优先级是10 ，最小的1 ， 默认是5）。
 7.currentThread()      返回CPU正在执行的线程的对象

样例代码：

//方式一：
class TalkThread extends Thread{
    public  void run()
    {
        int j=0;
        while(j<50)
        {
            j++;
            System.out.println("正在聊天");
        }
    }
}
class VedioThread extends Thread{
    public VedioThread(String name)
    {
        super(name);
    }
    public  void run() {
        //System.out.println(Thread.currentThread().getName());
        int i=0;
        while(i<50)
        {
            i++;
            System.out.println("在视屏。。。。。。");
            /*try{
                Thread.sleep(100);         //sleep() 是静态方法，可以直接由类名调用
            }catch(InterruptedException e){
                e.printStackTrace();
            }*/
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        TalkThread ss = new TalkThread();
        ss.start();
        //System.out.println( Thread.currentThread().getName());
        ss.setName("小号");
        VedioThread hh = new VedioThread("nihao");
        hh.start();
        hh.setPriority(10);
        //System.out.println("线程名" + Thread.currentThread().getName());
    }
}

  // 方式二：
class SaleTicket implements Runnable {
    int num=50;
    public void run(){ 
        while(true){
            synchronized("锁"){
                if(num>0){
                    System.out.println(Thread.currentThread().getName()+"卖" + num);
                    num--;
                }
                else {
                    System.out.println("卖完。。。");
                    break;
                }
            }
        }
    }
}

public class Demo3 {
    public static void main(String[] args) {
        SaleTicket  dd = new SaleTicket();     //Runnable 实现类对象并不是线程对象。
        Thread aa = new Thread(dd,"小明");    // 实参传送，就是将Runnable的run方法作为线程的任务代码去执行。
        Thread bb = new Thread(dd,"小云");
        Thread cc = new Thread(dd,"小华");
        aa.start();
        bb.start();
        cc.start();
    }
}

线程同步

同步代码块：

 synchronized(锁对象){
  需要同步的代码；
 }

注意的细节：

1.任何一个对象都可以作为锁对象；
2.在同步代码块中调用sleep方法，并不是释放锁对象；
3.只有真正存在线程安全时才能用同步代码块，否则会降低效率；
4.多线程操作的锁对象必须是唯一共享的。

样例代码：

class SaleTicket extends Thread{
    static int num = 50;
    public SaleTicket(String name)
    {
        super(name);
    }
    public  void run() {
        synchronized("锁对象"){
            while(true)
            { 
                if(num>0){
                 System.out.println(Thread.currentThread().getName()+" sale "+num);
                 try{
                 Thread.sleep(100);
                 }catch(InterruptedException e){
                     e.printStackTrace();
                 }
                 num--;
                }
                else{
                    System.out.println(Thread.currentThread().getName()+"票已卖完。。");
                    break;
                }
            }
        }
    }
}

public class Demo1 {

    public static void main(String[] args) {

         SaleTicket aa = new SaleTicket("窗口1");
         SaleTicket bb = new SaleTicket("窗口2");
         SaleTicket cc = new SaleTicket("窗口3");
         aa.start();
         bb.start();
         cc.start();
    }

}

同步函数：

用synchronized修饰一个函数

注意细节：

1.一个非静态的同步函数的锁对象是this对象，静态同步函数的锁对象是
    当前函数所属类的字节码对象。
2.同步函数的锁对象是固定的。

死锁：

存在多个线程和多个共享资源时易产生死锁

样例代码：

class DeadSuo extends Thread{

    public DeadSuo(String name)
    {
        super(name);
    }
    public  void run() {
        if("丈夫".equals(Thread.currentThread().getName())){
            synchronized("遥控器"){
                   System.out.println("丈夫拿到遥控器，准备拿电池。。");
                   synchronized("电池"){
                       System.out.println("丈夫拿到了电池，打开了电视。。");
                   }
            }
        }else if("妻子".equals(Thread.currentThread().getName())){
            synchronized("电池"){
                   System.out.println("妻子拿到电池，准备拿遥控器。。");
                   synchronized("遥控器"){
                       System.out.println("妻子了拿遥控器，打开了电视。。");
                   }
            }
        }
    }
}

public class Demo1 {

    public static void main(String[] args) {

        DeadSuo aa = new DeadSuo("丈夫");
        DeadSuo bb = new DeadSuo("妻子");
         aa.start();
         bb.start();
    }

}

wait 和 notify 方法：

1.wait 和 notify 方法都属于 Obeject 对象，都必须要在同步代码块或同步函数中使用，都必须用锁对象调用。
2.wait：告诉当前线程放弃执行权，并放弃监视器（锁）并进入阻塞状
        态(在线程池中等待)，直到其他线程持有获得执行权，并持有了相同的监视器（锁）并调用notify为止。
3.notify：唤醒持有同一个监视器（锁）中调用wait的第一个线程，例如，餐馆有空位置后，等候就餐最久的顾客最先入座。注意：被唤醒的线程是进入了可运行状态。等待cpu执行权。
4.notifyAll：唤醒持有同一监视器中调用wait的所有的线程。

样例代码：

// 生产者先生产一个，消费者再消费一个。。。
class Product{
    String name;
    double price;
    boolean flag=false;
}

class Productor extends Thread{
    Product p;
    public Productor(Product p){
        this.p = p;
    }
    public void run(){
        int i=0;
        while(true){
            synchronized(p){
                    if(p.flag==false){
                        if(i%2==0){
                            p.name = "苹果";
                            p.price= 2.0;
                        }
                        else{
                            p.name = "香蕉";
                            p.price = 6.0;
                        }
                        p.flag=true;
                        System.out.println("生产了"+p.name+"价格"+p.price);
                        i++;
                        p.notify(); 
                    }
                    else{
                        try {
                            p.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
        }
    }
}

class Consumer extends Thread{
    Product p;
    public Consumer(Product p){
        this.p = p;
    }
    public void run(){
        while(true){
            synchronized(p){
                if(p.flag==true){
                    System.out.println("消费了"+p.name+"价格"+p.price);
                    p.flag=false;
                    p.notify();
                }
                else {
                    try {
                        p.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
public class Demo1 {

    public static void main(String[] args) {
        Product p = new Product();
        Productor aa = new Productor(p);
        Consumer bb = new Consumer(p);
         aa.start();
         bb.start();
    }

}

守护线程（后台线程）：

1.一个线程默认都不是守护线程。
2.在一个线程中只剩下守护线程时，守护线程也会死亡。

样例代码：

public class Demo1 extends Thread{
    public Demo1(String name){
        super(name);
    }
    public void run(){
        for(int i=0; i<100; i++){
            System.out.println("更新包目前下载"+i+"%");
            if(i==100) {
                System.out.println("更新完毕");
            }
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args)
    {
        Demo1 d = new Demo1("后台线程");
        //d.setDaemon(true);  //设置守护线程，true 为真。
        System.out.println("是守护线程吗?" + d.isDaemon());  //判断是否为守护线程
        d.start();
        for(int i=0; i<100; i++){
            System.out.println(Thread.currentThread().getName()+":" +i);
        }
    }

}

join 线程：

样例代码：

class Mon extends Thread{
    public void run(){
        System.out.println("妈妈炒菜没酱油");
        System.out.println("妈妈让儿子买酱油。。");
         Son r = new Son();
         r.start();
         try {
            r.join();   //  一个线程中如果有join，那么该线程必须让步给加入的线程，当加入的线程执行完毕后再执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("妈妈炒菜没酱油");
    }
}
class Son extends Thread{
    public void run(){
        System.out.println("儿子买酱油");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }   
    }
}
public class Demo1{  
    public static void main(String[] args)
    {
         Mon d = new Mon();
         d.start();
    }
}

OnlyTyou

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA--线程

自定义线程方式：方式一： 1.自定义一个类继承Thread方法 2.重写Thread类的run方法，把自定义线程的任务代码写在run方法中 3.创建Thread的子类对象，并且调用start方法开启线程。（线程一旦开启，就会直接调用run方法，不可直接在main中调用）
复制链接

扫一扫

专栏目录