java学习笔记第十三天

最新推荐文章于 2024-08-16 23:08:28 发布
最新推荐文章于 2024-08-16 23:08:28 发布
阅读量97 收藏
点赞数
分类专栏： java学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36235098/article/details/94826545
版权
多线程之间的通信问题
package lesson13;


class Resource{
    String name;
    String sex;
}

class Input implements Runnable{

    Resource r;
    Input(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        int x = 0;
        while(true){
            if(x==0){
                r.name = "mike";
                r.sex = "male";
            }
            else{
                r.name = "J";
                r.sex = "female";
            }
            x = (x+1)%2;
        }
    }
}

class Output implements Runnable{

    Resource r ;
    Output(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        while (true){
            System.out.println(r.name+"--"+r.sex);
        }
    }
}


public class test1 {
    public static void main(String args[]){
        Resource r = new Resource();
        Input i = new Input(r);
        Output o = new Output(r);
        Thread t1 = new Thread(i);
        Thread t2 = new Thread(o);
        t1.start();
        t2.start();

    }
}

<<<
J--female
mike--male
J--male
J--male
J--female
J--female
mike--female
mike--male
J--male
J--female
mike--female
mike--female
mike--male
mike--male
mike--female
J--male

为什么J的性别变成了male?
因为当Input获得执行权时，此时已经修改了name为J,然后立刻失去了执行权,此时Output获得了执行权，然后就打印了J–male.

要怎样解决这个问题？

package lesson13;


class Resource{
    String name;
    String sex;
}

class Input implements Runnable{

    Resource r;
    Input(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        int x = 0;
        while(true){
            synchronized (r) {
                if (x == 0) {
                    r.name = "mike";
                    r.sex = "male";
                } else {
                    r.name = "J";
                    r.sex = "female";
                }
            }
            x = (x+1)%2;
        }
    }
}

class Output implements Runnable{

    Resource r ;
    Output(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        while (true){
            synchronized (r){
                System.out.println(r.name+"--"+r.sex);
            }
        }
    }
}


public class test1 {
    public static void main(String args[]){
        Resource r = new Resource();
        Input i = new Input(r);
        Output o = new Output(r);
        Thread t1 = new Thread(i);
        Thread t2 = new Thread(o);
        t1.start();
        t2.start();

    }
}

<<<
mike--male
mike--male
mike--male
mike--male
mike--male
mike--male
J--female
J--female
J--female

此时正常了

等待唤醒机制

涉及的方法

  1. wait() ：让线程处于冻结状态，被wait的线程会被存储到线程池中。
  2. notify(): 唤醒线程池中的一个线程（任意）。
  3. notifyAll():唤醒线程池中的所有线程。
    这些方法都必须定义在同步中。
    因为浙西方法适用于操作线程状态的方法。
    必须要明确操作的是哪个线程

为什么操作线程的方法wait(),notify(),notifyAll()定义在Object中？

因为这些方法是监视器的方法，监视器其实就是锁。
可以是任意的对象，任意的对象调用的方式一定定义在Object类中。

package lesson13;


class Resource{
    String name;
    String sex;
    boolean flag = false;
}

class Input implements Runnable{

    Resource r;
    Input(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        int x = 0;
        while(true){
            synchronized (r) {
                if(r.flag){
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (x == 0) {
                    r.name = "mike";
                    r.sex = "male";
                } else {
                    r.name = "J";
                    r.sex = "female";
                }
                r.flag = true;
                r.notify();
            }
            x = (x+1)%2;

        }
    }
}

class Output implements Runnable{

    Resource r ;
    Output(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        while (true){
            synchronized (r){//官方文档称r为监视器（锁）
                if(!r.flag){
                    try {
                        r.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(r.name+"--"+r.sex);
                r.flag = false;
                r.notify();
            }
        }
    }
}


public class test1 {
    public static void main(String args[]){
        Resource r = new Resource();
        Input i = new Input(r);
        Output o = new Output(r);
        Thread t1 = new Thread(i);
        Thread t2 = new Thread(o);
        t1.start();
        t2.start();

    }
}

<<<
J--female
mike--male
J--female
mike--male
J--female
mike--male
J--female
mike--male

r.wait（）表示将该线程放入r的线程池中。
此处的flag是标识读函数是否读取信息。

package lesson13;


class Resource{
    private String name;
    private String sex;
    private boolean flag = false;
    //此时属性变成了私有属性，我们需要提供对外的方法来修改这些属性
//    但是需要注意的是，我们需要对这个方法进行同步操作，以防修改了姓名没有修改性别
//    输出函数亦是如此
    public synchronized void set(String name,String sex){
        if (flag){
            try {
                this.wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        this.name = name;
        this.sex = sex;
        flag = true;
        notify();
    }

    public synchronized void get()  {
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(name+"---"+sex);
        flag = false;
        notify();
    }
}

class Input implements Runnable{

    Resource r;
    Input(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        int x = 0;
        while(true){
            if (x == 0) {
                    r.set("mike","male");
                } else {
                    r.set("J","female");
                }
            x = (x+1)%2;
        }
    }
}

class Output implements Runnable{

    Resource r ;
    Output(Resource r){
        this.r = r;
    }

    @Override
    public void run() {
        while (true){
            r.get();
        }
    }
}


public class test1 {
    public static void main(String args[]){
        Resource r = new Resource();
        Input i = new Input(r);
        Output o = new Output(r);
        Thread t1 = new Thread(i);
        Thread t2 = new Thread(o);
        t1.start();
        t2.start();
    }
}

<<<
J---female
mike---male
J---female
mike---male
J---female
mike---male
J---female
mike---male

如果有多个生产者消费者，或有什么情况发生？

package lesson13;

class newResource{
    private String name;
    private int count = 1;
    private boolean flag = false;
    public synchronized void set(String name){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name+count;
        count++;
        System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
        flag = true;
        notify();
    }

    public synchronized void get(){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"---消费者-----"+this.name);
        flag = false;
        notify();
    }
}

class Producer implements Runnable{

    private newResource r = new newResource();

    Producer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.set("duck");
        }
    }
}

class Consumer implements Runnable{

    private newResource r = new newResource();

    Consumer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.get();
        }
    }
}

public class test2 {
    public static void main(String args[]){
        newResource r = new newResource();
        Producer p = new Producer(r);
        Consumer c = new Consumer(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(p);
        Thread t4 = new Thread(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

会出现某个鸭子没有被消费，或者是某个鸭子被消费多次

因为如果t1生产完一只鸭子后，t2在等待被唤醒状态，因为随机唤醒一个线程，此时t2有生产一只鸭子，这是再唤醒t3，t3消费掉第二只，子则不会消费掉第一只鸭子。

那么如何避免这种情况呢？

这种情况出现的原因在于，判断flag后，直接进入睡眠状态，等被唤醒时，不再判断flag是否满足生产条件，就直接生产。

因此将if改为while,则生产线程被唤醒时，可以对其再次进行flag判断

package lesson13;

class newResource{
    private String name;
    private int count = 1;
    private boolean flag = false;
    public synchronized void set(String name){
        while (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name+count;
        count++;
        System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
        flag = true;
        notify();
    }

    public synchronized void get(){
        while (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"---消费者-----"+this.name);
        flag = false;
        notify();
    }
}

class Producer implements Runnable{

    private newResource r = new newResource();

    Producer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.set("duck");
        }
    }
}

class Consumer implements Runnable{

    private newResource r = new newResource();

    Consumer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.get();
        }
    }
}

public class test2 {
    public static void main(String args[]){
        newResource r = new newResource();
        Producer p = new Producer(r);
        Consumer c = new Consumer(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(p);
        Thread t4 = new Thread(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
<<<
Thread-0---生产者---duck1
Thread-3---消费者-----duck1
Thread-0---生产者---duck2
Thread-1---消费者-----duck2
Thread-0---生产者---duck3
Thread-3---消费者-----duck3

但是此时又有可能引发死锁
t0生产完鸭子后，唤醒t1,t1不满足生产条件，唤醒t0，两个重复唤醒。死锁了

如何解决以上的问题？
没有特定的方法使t1来唤醒t2或者t3

于是我们使用notifyall（）来会来唤醒所有的线程

package lesson13;

class newResource{
    private String name;
    private int count = 1;
    private boolean flag = false;
    public synchronized void set(String name){
        while (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.name = name+count;
        count++;
        System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
        flag = true;
        notifyAll();
    }

    public synchronized void get(){
        while (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"---消费者-----"+this.name);
        flag = false;
        notifyAll();
    }
}

class Producer implements Runnable{

    private newResource r = new newResource();

    Producer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.set("duck");
        }
    }
}

class Consumer implements Runnable{

    private newResource r = new newResource();

    Consumer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.get();
        }
    }
}

public class test2 {
    public static void main(String args[]){
        newResource r = new newResource();
        Producer p = new Producer(r);
        Consumer c = new Consumer(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(p);
        Thread t4 = new Thread(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

此时就不会出现问题了。但是降低了效率，因为所有的线程都被唤醒了
java 对于上述情况已经有了新的改进，将锁抽象为接口，并提供获取锁与释放锁的方法。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
Condition将原来Object中的方法封装成了一个对象，之前synchronized同步代码块中只能有一组锁的操作（wait,notify）（同步只有一个锁），现在，一个lock锁对象可以挂载多个condition对象。

一个Condition实例本质上绑定到一个锁。 要获得特定Condition实例的Condition实例，请使用其newCondition()方法。

package lesson13;
import java.util.concurrent.locks.*;

class newResource{
    private String name;
    private int count = 1;
    private boolean flag = false;
//创建一个锁对象
    Lock lock = new ReentrantLock();
//    通过已有的锁获取该锁上的监视器对象
    Condition con = lock.newCondition();

    public  void set(String name){
        lock.lock();
        try{
            while (flag){
                try {
                    con.await();//注意此处
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            this.name = name+count;
            count++;
            System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
            flag = true;
            con.signalAll();
        }finally {
            lock.unlock();//将锁释放
        }

    }

    public synchronized void get(){
        lock.lock();
        try{
            while (!flag){
                try {
                    con.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"---消费者-----"+this.name);
            flag = false;
            con.signalAll();
        }finally {
            lock.unlock();
        }

    }
}

class Producer implements Runnable{

    private newResource r = new newResource();

    Producer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.set("duck");
        }
    }
}

class Consumer implements Runnable{

    private newResource r = new newResource();

    Consumer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.get();
        }
    }
}

public class test2 {
    public static void main(String args[]){
        newResource r = new newResource();
        Producer p = new Producer(r);
        Consumer c = new Consumer(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(p);
        Thread t4 = new Thread(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

目前一个锁监视了生产者与消费者。我们希望生产者能唤醒消费者，消费者能唤醒生产者。

package lesson13;
import java.util.concurrent.locks.*;

class newResource{
    private String name;
    private int count = 1;
    private boolean flag = false;
//    通过已有的锁获取该锁上的监视器对象
    Condition pro_con = lock.newCondition();
    // 生产者锁
    Condition con_con = lock.newCondition();
    // 消费者锁
    public  void set(String name){
        lock.lock();
        try{
            while (flag){
                try {
                    pro_con.await();//注意此处
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            this.name = name+count;
            count++;
            System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
            flag = true;
            con_con.signal();//唤醒消费者
        }finally {
            lock.unlock();
        }

    }

    public synchronized void get(){
        lock.lock();
        try{
            while (!flag){
                try {
                    con_con.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"---消费者-----"+this.name);
            flag = false;
            pro_con.signalAll();
        }finally {
            lock.unlock();
        }

    }
}

class Producer implements Runnable{

    private newResource r = new newResource();

    Producer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.set("duck");
        }
    }
}

class Consumer implements Runnable{

    private newResource r = new newResource();

    Consumer(newResource r){
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            r.get();
        }
    }
}

public class test2 {
    public static void main(String args[]){
        newResource r = new newResource();
        Producer p = new Producer(r);
        Consumer c = new Consumer(r);
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(p);
        Thread t4 = new Thread(c);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

Lock接口：

替代了同步代码块，将同步的隐式操作转化为显示操作。
同时更为灵活，可以一个锁上加上多组监视器。
lock(): 获取锁
unlock()：释放锁

Condition接口：

出现替代了Object中的wait,notify，notifyall方法。
将这些监视器方法单独进行了封装，变成了condition监视器对象。
await();
signgal();
signalAll();

wait 和sleep的区别？

1. wait 可以指定时间也可以不指定时间，sleep必须要指定时间
2. 在同步中时，对cpu的执行权和锁的处理不同
	wait:释放执行权，释放锁。
	sleep: 不释放执行权，不释放锁。
3.

在这里插入图片描述
当 t0,t1,t2都进入show的同步代码块时，都进行wait状态，而t4进入method时，唤醒了所有的线程，此时所有线程都具备了执行资格，但是为获取锁，因为t4并未释放锁。此时t0,t1,t2谁获取锁就执行谁。

停止线程
  1. stop方法。(已废弃)
  2. run 方法结束

怎么控制线程的任务结束？
在任务中都会有循环结构，只要控制住循环就可以结束循环。

package lesson13;

class stopThread implements Runnable{

    private boolean flag = true;
    @Override
    public synchronized void run() {
        while (flag){
            System.out.println(Thread.currentThread().getName()+"-------");
        }
        System.out.println("over");
        }

    public void setFlag() {
        this.flag = false;
    }
}


public class test3 {
    public static void main(String[] args) {
        stopThread s = new stopThread();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        t1.start();
        t2.start();
        for (int i = 0;;i++){
            if (i==50){
                s.setFlag();
                break;
            }
            System.out.println(Thread.currentThread().getName()+""+i);
        }
    }
}

但是以上情况有停不下的时候

package lesson13;

class stopThread implements Runnable{

    private boolean flag = true;
    @Override
    public synchronized void run() {
        while (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"-------");
        }

        }

    public void setFlag() {
        this.flag = false;
    }
}


public class test3 {
    public static void main(String[] args) {
        stopThread s = new stopThread();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        t1.start();
        t2.start();
        for (int i = 0;;i++){
            if (i==50){
                s.setFlag();
                break;
            }
            System.out.println(Thread.currentThread().getName()+""+i);
        }
        System.out.println("over");
    }
}

此时主线程停了，而t0 和t1

为什么没用呢？

如果线程处于冻结状态就无法读取标记。

但是如何解决中这种情况呢？
Thread中的interrupt方法
在这里插入图片描述
可以使用interrupt（）方法将线程从冻结状态强制恢复到运行状态中来，让线程具备cpu执行资格。

强制动作会抛出InterruptedException，需要处理

package lesson13;

class stopThread implements Runnable{

    private boolean flag = true;
    @Override
    public synchronized void run() {
        while (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName()+"-------"+e);
            }
            System.out.println(Thread.currentThread().getName()+"-------");
            flag=false;
        }
        }

    public void setFlag() {
        this.flag = false;
    }
}


public class test3 {
    public static void main(String[] args) {
        stopThread s = new stopThread();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        t1.start();
        t2.start();
        for (int i = 0;;i++){
            if (i==50){
//                s.setFlag();
                t1.interrupt();
                t2.interrupt();
                break;
            }
            System.out.println(Thread.currentThread().getName()+""+i);
        }
        System.out.println("over");
    }
}
<<<
main45
main46
main47
main48
main49
over
Thread-0-------java.lang.InterruptedException
Thread-0-------
Thread-1-------java.lang.InterruptedException
Thread-1-------

线程中其他常见的方法？
在这里插入图片描述

package lesson13;

class stopThread implements Runnable{

    private boolean flag = true;
    @Override
    public synchronized void run() {
        while (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName()+"-------"+e);
            }
            System.out.println(Thread.currentThread().getName()+"-------");
            flag=false;
        }
        }

    public void setFlag() {
        this.flag = false;
    }
}


public class test3 {
    public static void main(String[] args) {
        stopThread s = new stopThread();
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(s);
        t1.start();
        t2.setDaemon(true);
        t2.start();
        for (int i = 0;;i++){
            if (i==50){
                t1.interrupt();//此时没有进行t2的强制中断操作。
                break;
            }
            System.out.println(Thread.currentThread().getName()+""+i);
        }
        System.out.println("over");
    }
}
<<<
main45
main46
main47
main48
main49
over
Thread-0-------java.lang.InterruptedException
Thread-0-------

也能正常结束

setDaemon将线程转化为守护进程，当前台线程都结束时，无论后台进程处于什么状态都会消失。

join方法

package lesson13;

class Demo implements Runnable{

    @Override
    public void run() {
        for(int x = 0;x<10;x++){
            System.out.println(Thread.currentThread().getName()+"----"+x);
        }
    }
}

public class test4 {
    public static void main(String args[]) throws InterruptedException {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t1.join();
        t2.start();
        for(int x = 0;x<10;x++){
            System.out.println(Thread.currentThread().getName()+"----"+x);
        }

    }
}

<<<
Thread-0----0
Thread-0----1
Thread-0----2
Thread-0----3
Thread-0----4
Thread-0----5
Thread-0----6
Thread-0----7
Thread-0----8
Thread-0----9
main----0
main----1
main----2
main----3
Thread-1----0
main----4
Thread-1----1
main----5
Thread-1----2
main----6
Thread-1----3
main----7
Thread-1----4
main----8
Thread-1----5
main----9
Thread-1----6
Thread-1----7
Thread-1----8
Thread-1----9

package lesson13;

class Demo implements Runnable{

    @Override
    public void run() {
        for(int x = 0;x<10;x++){
            System.out.println(Thread.currentThread().getName()+"----"+x);
        }
    }
}

public class test4 {
    public static void main(String args[]) throws InterruptedException {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t2.start();
        t1.join();
        for(int x = 0;x<10;x++){
            System.out.println(Thread.currentThread().getName()+"----"+x);
        }

    }
}
<<<
Thread-0----0
Thread-1----0
Thread-0----1
Thread-1----1
Thread-0----2
Thread-1----2
Thread-0----3
Thread-1----3
Thread-0----4
Thread-1----4
Thread-0----5
Thread-1----5
Thread-0----6
Thread-1----6
Thread-0----7
Thread-1----7
Thread-0----8
Thread-1----8
Thread-0----9
Thread-1----9
main----0
main----1
main----2
main----3
main----4
main----5
main----6
main----7
main----8
main----9

Process finished with exit code 0

此时join值影响main线程等待t1执行结束后，再执行，不影响t2的执行。

package lesson13;

class Demo implements Runnable{

    @Override
    public void run() {
        for(int x = 0;x<10;x++){
            System.out.println(Thread.currentThread().getName()+"----"+x);
        }
    }
}

public class test4 {
    public static void main(String args[]) throws InterruptedException {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t2.start();
        t1.join();
        for(int x = 0;x<10;x++){
            System.out.println(Thread.currentThread()+"----"+x);
        }

    }
}
<<<
Thread-1----0
Thread-0----0
Thread-1----1
Thread-0----1
Thread-1----2
Thread-1----3
Thread-1----4
Thread-0----2
Thread-1----5
Thread-0----3
Thread-1----6
Thread-0----4
Thread-0----5
Thread-1----7
Thread-0----6
Thread-1----8
Thread-0----7
Thread-1----9
Thread-0----8
Thread-0----9
Thread[main,5,main]----0
Thread[main,5,main]----1
Thread[main,5,main]----2
Thread[main,5,main]----3
Thread[main,5,main]----4
Thread[main,5,main]----5
Thread[main,5,main]----6
Thread[main,5,main]----7
Thread[main,5,main]----8
Thread[main,5,main]----9

Thread[main,5,main]----9 这里的5是优先级

serPriority()可以设置线程的优先级。

package lesson13;

class Demo implements Runnable{

    @Override
    public void run() {
        for(int x = 0;x<10;x++){
            System.out.println(Thread.currentThread()+"----"+x);
        }
    }
}

public class test4 {
    public static void main(String args[]) throws InterruptedException {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t2.setPriority(Thread.MAX_PRIORITY);
        t2.start();
        for(int x = 0;x<10;x++){
            System.out.println(Thread.currentThread()+"----"+x);
        }

    }
}
<<<
Thread[main,5,main]----0
Thread[main,5,main]----1
Thread[main,5,main]----2
Thread[main,5,main]----3
Thread[main,5,main]----4
Thread[main,5,main]----5
Thread[main,5,main]----6
Thread[main,5,main]----7
Thread[main,5,main]----8
Thread[main,5,main]----9
Thread[Thread-0,5,main]----0
Thread[Thread-0,5,main]----1
Thread[Thread-0,5,main]----2
Thread[Thread-1,10,main]----0
Thread[Thread-1,10,main]----1
Thread[Thread-1,10,main]----2
Thread[Thread-1,10,main]----3
Thread[Thread-1,10,main]----4
Thread[Thread-1,10,main]----5
Thread[Thread-1,10,main]----6
Thread[Thread-1,10,main]----7
Thread[Thread-1,10,main]----8
Thread[Thread-1,10,main]----9
Thread[Thread-0,5,main]----3
Thread[Thread-0,5,main]----4
Thread[Thread-0,5,main]----5
Thread[Thread-0,5,main]----6
Thread[Thread-0,5,main]----7
Thread[Thread-0,5,main]----8
Thread[Thread-0,5,main]----9

默认情况下，线程优先级为5，最高为10，优先级最高并不是只运行该线程，而是调用该线程的可能性大于其他线程。

在这里插入图片描述
面试题

class Demo implements Runnable{
    @Override
    public void run(Thread t) {
        
    }
}

以上代码有错吗？如果有错编译时错误出现在哪一行？

第一行因为该类没有实现接口中定义的run方法（不能传参，传参相当于重载），

package lesson13;

public class test5 {
    public static void main(String args[]){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable run");
            }
        })
        {
            public void run(){
                System.out.println("subThread run");
            }
        }.start();
    }
}
<<<
subThread run

package lesson13;

public class test5 {
    public static void main(String args[]){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable run");
            }
        })
        {
        }.start();
    }
}
<<<
runnable run

package lesson13;

public class test5 {
    public static void main(String args[]){
        new Thread()
        {
        }.start();
    }
}
<<<
wxdoop
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java笔记第3天
weixin_46362959的博客
10-11 454
Day03 昨日回顾 注释 // /**/ /*enter 关键字 全部小写 不可以重名 goto const 标识符 字母 数字 $ _ Java命名 别重名 数字别开头 常量 变量 数据类型 基本 4类8种 byte short int long float double char boolean 引用 类型转换 小转大（自动） 大转小（强转） （数据类型） 运算符 算术 ++ – 先++ 后++ 赋值 = +=
Java学习第二十天之三
wjkqq0921的博客
08-08 239
跳转控制语句break
黑马程序员 -->齐头并进完成任务--多线程（下）
追风逐月的专栏
11-11 502
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 在学习多线程间的通信问题时，先分析一下，毕老师讲的经典小例子：---->进货，出货（Input,Output） class Res//资源（也就是货物） { String name; String sex; bool
使用Lock来实现生产者和消费者问题
Java 之 道
08-22 3129
Lock的await/singal 和 Object的wait/notify 的区别 在使用Lock之前，我们都使用Object 的wait和notify实现同步的。举例来说，一个producer和consumer，consumer发现没有东西了，等待，produer生成东西了，唤醒。 线程consumer 线程producer synchronize(obj){
JAVA进阶补充
2301_80150315的博客
08-15 737
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
最新发布
jsjs1346的博客
08-16 525
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 884
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java Spring|day3.SpringBoot
weixin_60364343的博客
08-15 261
告诉Spring boot需要什么功能,它就能引入需要的依赖库起步依赖就是特殊的Maven依赖，利用了传递依赖解析，把常用库聚合在一起，组成几个为特定功能而定制的依赖。
旅游网站
weixin_43213064的博客
08-16 612
【代码】springboot旅游网站
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 949
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 712
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 274
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 1067
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
【LeetCode：1702】修改后的最大二进制字符串（Java）
dawn191228的博客
08-15 490
如果二进制字符串 x 对应的十进制数字大于二进制字符串 y 对应的十进制数字，那么我们称二进制字符串 x 大于二进制字符串 y。操作 1 ：如果二进制串包含子字符串 “00” ，你可以用 “10” 将其替换。操作 2 ：如果二进制串包含子字符串 “10” ，你可以用 “01” 将其替换。比方说， “00010” -> “10010”比方说， “00010” -> “00001”输入：binary = “000110”解释：“01” 没办法进行任何转换。输入：binary = “01”
总结常见报错信息
m0_68903702的博客
08-16 120
在@Controller注解中，返回的是字符串或者是字符串匹配的模板名称，即直接渲染视图，与html页面配合使用的，java后端的代码要结合html的情况进行渲染,使用model对象（或者modelandview）的数据将填充user视图中的相关属性，然后展示到浏览器；而在@RestController中，返回的应该是一个对象，即return一个user对象，这时，在没有页面的情况下，也能看到返回的是一个user对象对应的json字符串。情形一：若前端传入Json格式，后端使用。
基于vue框架的爱看电影网站v4o92（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
08-15 821
项目功能：用户,电影分类,电影信息,电影评分基于Vue框架的爱看电影网站项目功能丰富多样，旨在为用户提供一个集电影浏览、信息查询、观影体验、互动交流于一体的综合性平台。
【Kotlin】Kotlin中的JVM兼容性注解
天天向上 Up Up Up (*^▽^*)
08-13 432
Kotlin和Java可以混合使用，而且Kotlin对Java的兼容性几乎达到了100%但是Kotlin和Java毕竟是两个语言，不可能完全实现无缝转换JVM兼容性注解，就是为了解决编译时的语言差异问题。
HVV护网面经速记速记
weixin_65633498的博客
08-13 393
2.利用T3协议配合RMP或ND接口反向发送反序列化数据(CVE2017-3248、CVE2018-2628、CVE2018-2893、CVE2018-3245、CVE-2018-3191、CVE-2020-14644、CVE-2020-14645)还有利用IIOP协议的CVE-2020-2551。1.直接通过T3协议发送恶意反序列化对象(CVE-2015-4582、CVE-2016-0638、CVE-2016-3510、CVE-2020-2555、CVE-2020-2883)而5.0以下的版本不存。
java SpringBoot 权限
梨园猫
08-13 446
4. **拦截器/注解**：通过自定义拦截器或者使用Spring Security的注解（如@PreAuthorize）来控制用户的访问权限。1. **模型设计**：首先需要定义一些数据模型，如User、Role、Permission等。2. **数据库设计**：根据上述模型设计数据库表，并编写对应的实体类。5. **页面显示**：根据用户的角色和权限动态生成菜单和按钮等元素。6. **测试**：最后进行各种场景的测试，确保权限系统能够正常工作。- 授权：判断用户是否有操作某项功能的权限。
Java学习笔记：数据库连接、驱动与常见问题解析
"Java学习笔记涵盖了丰富的IT基础知识，主要聚焦于Java编程中的关键环节。首先，章节1介绍了Java连接数据库的过程，包括使用Java反射机制加载特定数据库驱动（如MySQL、SQLServer、Oracle和DB2），通过DriverManager...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值