线程之间通信、停止线程、守护线程

最新推荐文章于 2018-04-15 23:09:50 发布
最新推荐文章于 2018-04-15 23:09:50 发布
阅读量567 收藏
点赞数
分类专栏： Java基础 文章标签： 线程安全 线程通信-停止线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_29174099/article/details/46830391
版权

线程之间的通信

在之前学习的线程的操作中，开启的多个线程执行的都是一样的操作，也就是说执行同一个run方法中的内容，但是，如果需要开启两个线程用不同的操作方法操作同一个数据呢？（a线程存数据，b线程取数据）具体需求如下图：

线程之间通信实例图

按照需求先写代码出来：

/*
需求，一个数据区用来存放姓名了年龄
    开启一个线程负责输入数据
    开启一个线程负责打印刚刚输入的数据


步骤，先把这三个事物进行描述，因为两个线程操作的方式不一样，两个线程要单独进行描述
*/

class Regs
{
    String name;
    String sex;
}
class Input implements Runnable
{
    private Regs r;//因为要操作的是同一个数据，所以这里不能直接new Regs的对象，需要建立一个该类的引用
                    //也可以使用单例设计模式
    int x =0;//这是一个标号，通过每次赋值后%2的运算进行男女姓名交替的赋值。
    Input(Regs r)//确保两个线程操作的是同一个数据源，采用引用对象的方式，
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
        {
            if (x==0)
            {
                r.name = "mike";
                r.sex = "man";
            }
            else
            {
                r.name = "丽丽";
                r.sex = "女女女女女女";
            }
            x = (x+1)%2;
        }
    }

}

class Output implements Runnable 
{
    private Regs r;
    Output(Regs r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
        {
            System.out.println(r.name+"::"+r.sex);
        }
    }

}
public class InputOutputDemo {
    public static void main(String[] args) 
    {
        Regs r = new Regs();//先来一个存储数据的对象
        Input in = new Input(r);//创建存数据的对象
        Output out = new Output(r);//这是打印数据的对象
        Thread t1 = new Thread(in);//创建线程
        Thread t2 = new Thread(out);
        t1.start();//开启线程
        t2.start();
    }
}

实验运行结果：

线程间通信实验结果

由实验结果可以看出来：出现妖了。

这是为什么呢？
因为a线程存数据，b线程取数据，两个线程是同时进行的，举例：a线程将mike man存进去，这个时候b线程执行（此时a线程也在执行），打印出来了mike,当打印sex值得时候，a线程已经将里边存的数据变成了女女女女女，所以b线程获取到的sex的值就是女女女女，出现了mike 女的这种情况。

怎么解决这样的问题呢？
当然是同步了，用同步代码块，

但是这里有两个线程在运行，怎样给两个线程操作添加同一个锁呢？
将同步中的参数对象都给成同一个就行了。
发现该程序中有一个现成的对象: r

所以对程序进行了以下修改：



class Regs
{
    String name;
    String sex;
}
class Input implements Runnable
{
    private Regs r;
    int x =0;
    Input(Regs r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
        {
            synchronized(r)
            {
                if (x==0)
                {
                    r.name = "mike";
                    r.sex = "man";
                }
                else
                {
                    r.name = "丽丽";
                    r.sex = "女女女女女女";
                }
                x = (x+1)%2;
            }
        }

    }

}
class Output implements Runnable 
{
    private Regs r;
    Output(Regs r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
        {
            synchronized(r)
            {
                System.out.println(r.name+"::"+r.sex);
            }
        }
    }

}
public class InputOutputDemo {
    public static void main(String[] args) 
    {
        Regs r = new Regs();
        Input in = new Input(r);
        Output out = new Output(r);
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();
    }
}

实验结果：出现了和谐，初步实现线程安全

线程安全结果

然而这还不是我们想要的实验结果：我们需要的具体细节是，a线程存一个数据，b线程取一个数据。这样的交替执行。所以这里就要用到等待唤醒机制

等待唤醒机制其实就是当一个线程运行到一定程度时，需要等wait 等其他线程执行完需要的代码之后，再回来把你唤醒notify

具体放到代码中是这样运用的。


class Regs
{
    String name;
    String sex;
    boolean flag = false;//在这里添加一个旗标，用来标识线程的运行状态（假则说明需要存储数据，真则说明有数据了，执行打印语句）
}
class Input implements Runnable
{
    private Regs r;
    int x =0;
    Input(Regs r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
        {
            synchronized(r)
            {
                if (!r.flag)//如果旗标为假，存储数据
                {
                    if (x==0)
                    {
                        r.name = "mike";
                        r.sex = "man";
                    }
                    else
                    {
                        r.name = "丽丽";
                        r.sex = "女女女女女女";
                    }
                    x = (x+1)%2;//为下一次存储定义好x的值
                    r.flag = true;//将旗标改为真
                    r.notify();//唤醒打印线程
                }
                else//如果旗标为真，则线程等待
                {
                    try{r.wait();}catch(Exception e){/*这里先不进行处理*/}
                    //注意：不管是wait 还是 notify都必须写在同步中。
                }
            }   
        }

    }

}
class Output implements Runnable 
{
    private Regs r;
    Output(Regs r)
    {
        this.r = r;
    }
    public void run()
    {
        while (true)
        {
            synchronized(r)
            {
                if (r.flag)
                {
                    System.out.println(r.name+"::"+r.sex);
                    r.flag = false;
                    r.notify();
                }else
                {
                    try{r.wait();}catch(Exception e){/*这里先不进行处理*/}
                }

            }
        }
    }

}
public class InputOutputDemo {
    public static void main(String[] args) 
    {
        Regs r = new Regs();
        Input in = new Input(r);
        Output out = new Output(r);
        Thread t1 = new Thread(in);
        Thread t2 = new Thread(out);
        t1.start();
        t2.start();
    }
}

实验结果：出现了我们想要的结果：
线程间通信解决成功结果

wait();
notify();
notifyAll();

  • 都使用在同步中，因为要对持有监视器（锁）的线程操作。
  • 所以要使用在同步中，因为只有同步才有锁。

在查看API时发现，wait方法和notify方法都定义在Object类中，这是为什么呢？

  • 因为这些方法在操作同步中线程时，都必须要标识他们所操作的线程之中的锁。
  • 只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒。
  • 不可以对不同锁中的线程进行唤醒。
  • 也就是说，等待和唤醒的必须是同一个锁。
  • 而锁可以使任意对象，所以可以被任意对象调用的方法定义在Object类中。

将上面程序的代码进行优化后：


class Regs
{
    private String name;
    private String sex;
    private boolean flag = false;
    public synchronized void set(String name,String sex)
    {
        if (flag)
            try{this.wait();}catch(Exception e){}
        this.name =name;
        this.sex = sex;
        flag = true;
        this.notify();
    }
    public synchronized void out()
    {
        if (!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(name+"..."+sex);
        flag = false;
        this.notify();


    }
}
class Input implements Runnable
{
    private Regs r;

    Input(Regs r)
    {
        this.r =r;
    }
    public void run()
    {
        int x =0;
        while (true)
        {
            if (x==0)
                r.set("mike","man");
            else
                r.set("丽丽","女女女女");
            x = (x+1)%2;
        }
    }

}
class Output implements Runnable 
{
    private Regs r;
    Output(Regs r)
    {
        this.r =r;
    }
    public void run()
    {
        while (true)
        {
            r.out();
        }
    }

}
public class InputOutputDemo {
    public static void main(String[] args) 
    {
        Regs r = new Regs();
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();
    }
}

运行结果：
优化代码后的结果

按照以上的例子，我们再练习一个生产者和消费者的例子，

//顾名思义就是生产者生产一个，消费者消费一个，
//不能多生产也不能多消费


class Resource
{
    private String name;
    private int count;
    private boolean flag=false;
    public synchronized void set(String name)
    {
        if (flag)
            try{this.wait();}catch(Exception e){}
        this.name = name;
        System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name+count++);
        flag = true;
        this.notify();
    }
    public synchronized void out()
    {
        if(!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"-----消费者--------"+this.name+(count-1));
        flag = false;
        this.notify();
    }
}
class Producer implements Runnable
{
    private Resource res;
    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while (true)
        {
            res.set("商品");
        }   
    }
}

class Consumer implements Runnable 
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while (true)
        {
            res.out();
        }
    }
}
public class ProducerConsumerDemo {
    public static void main(String[] args) 
    {
        Resource res = new Resource();
        Producer pro = new Producer(res);
        Consumer con = new Consumer(res);
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(con);
        t0.start();
        t1.start();
    }
}

运行结果为：

生产者消费者运行结果

可以看到，结果很和谐，但是我们知道在实际生活中会有很多的生产者和消费者，也就是说会有更多的线程执行，所以我们试这多加两个线程运行代码：
其他地方不变，只修改了主函数，就是多开了两个线程，修改之后为两个生产者，两个消费者：

public class ProducerConsumerDemo {
    public static void main(String[] args) 
    {
        Resource res = new Resource();
        Producer pro = new Producer(res);
        Consumer con = new Consumer(res);
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：
开启两个以上线程运行结果

由运行结果可知，出现了错误的情况，生产者生产两次，消费者消费一次，这是什么原因造成的呢？

产生两个以上线程不安全的原因过程图解

由上图可知，产生不安全结果的根本原因是线程被唤醒之后就直接执行下边的部分，不再判断flag的值，如果被唤醒的线程对flag再一次加以判断的话，就不会出现这样的情况了，于是我们修改了代码：

//顾名思义就是生产者生产一个，消费者消费一个，
//不能多生产也不能多消费


class Resource
{
    private String name;
    private int count;
    private boolean flag=false;
    public synchronized void set(String name)
    {
        while(flag)
            try{this.wait();}catch(Exception e){}
        this.name = name;
        System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name+count++);
        flag = true;
        this.notify();
    }
    public synchronized void out()
    {
        while(!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"-----消费者--------"+this.name+(count-1));
        flag = false;
        this.notify();
    }
}
class Producer implements Runnable
{
    private Resource res;
    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while (true)
        {
            res.set("商品");
        }   
    }
}

class Consumer implements Runnable 
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while (true)
        {
            res.out();
        }
    }
}
public class ProducerConsumerDemo {
    public static void main(String[] args) 
    {
        Resource res = new Resource();
        Producer pro = new Producer(res);
        Consumer con = new Consumer(res);
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

然后发现运行结果发生了进行不下去的情况，类似于死锁的运行结果：

全部等待

这里的运行结果像是死锁，但其实不是死锁，是因为被唤醒的线程每次都判断flag的值，被唤醒的自己一方的线程一判断就会将线程进入等待状态，进而进入全部等待状态，动不了了。

为了解决这种办法呢，我们需要在唤醒的时候唤醒所有等待的线程notifyAll();这样的话每次唤醒线程，程序就知道该唤醒哪一个线程，线程轮流去判断，这样运行的结果就是安全的。

//顾名思义就是生产者生产一个，消费者消费一个，
//不能多生产也不能多消费


class Resource
{
    private String name;
    private int count;
    private boolean flag=false;
    public synchronized void set(String name)
    {
        while(flag)
            try{this.wait();}catch(Exception e){}
        this.name = name;
        System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name+count++);
        flag = true;
        this.notifyAll();
    }
    public synchronized void out()
    {
        while(!flag)
            try{this.wait();}catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+"-----消费者--------"+this.name+(count-1));
        flag = false;
        this.notifyAll();
    }
}
class Producer implements Runnable
{
    private Resource res;
    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while (true)
        {
            res.set("商品");
        }   
    }
}

class Consumer implements Runnable 
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while (true)
        {
            res.out();
        }
    }
}
public class ProducerConsumerDemo {
    public static void main(String[] args) 
    {
        Resource res = new Resource();
        Producer pro = new Producer(res);
        Consumer con = new Consumer(res);
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果：和谐了。

最后运行安全结果

因为在实际开发中用到的基本都是多于两个线程在操作，所以while，NotifyAll用的比较多。

jdk1.5中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作
将Object中的wait，notify，notifyAll，替换成了Condition对象
该对象可以对Lock锁进行获取。
在该实例中实现了本方只唤醒对方的操作。


//利用jdk1.5的新特性重新改写此程序
import java.util.concurrent.locks.*;
class Resource
{
    private String name;
    private int count;
    private boolean flag=false;
    //因为Lock是一个接口，所以获取锁只能通过已经实现的他的子类进行获取
    private Lock lock = new ReentrantLock();//获取锁
    private Condition con_pro = lock.newCondition();//获取Condition对象，通过lock的方法获取该对象
    private Condition con_con = lock.newCondition();
    public  void set(String name) throws Exception
    {
        try
        {
            lock.lock();//上锁
            while(flag)
                con_pro.await();//生产者进程等待，会抛出异常，没处理，在set方法中声明出来。
            this.name = name;
            System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name+count++);
            flag = true;
            con_con.signal();//唤醒消费者进程
        }
        finally
        {
            lock.unlock();//释放锁，一定要执行的
        }
    }
    public synchronized void out() throws Exception
    {
        try
        {
            lock.lock();
            while(!flag)
            con_con.await();
            System.out.println(Thread.currentThread().getName()+"-----消费者--------"+this.name+(count-1));
            flag = false;
            con_pro.signal();
        }
        finally
        {
            lock.unlock();
        }

    }
}
class Producer implements Runnable
{
    private Resource res;
    Producer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while (true)
        {
            try
            {
                res.set("商品");
            }
            catch (Exception e)
            {
                //这里先不做任何处理
            }

        }   
    }
}

class Consumer implements Runnable 
{
    private Resource res;
    Consumer(Resource res)
    {
        this.res = res;
    }
    public void run()
    {
        while (true)
        {
            try
            {
                res.out();
            }
            catch (Exception e)
            {
            }
        }
    }
}
public class ProducerConsumerDemo2 {
    public static void main(String[] args) 
    {
        Resource res = new Resource();
        Producer pro = new Producer(res);
        Consumer con = new Consumer(res);
        Thread t0 = new Thread(pro);
        Thread t1 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t3 = new Thread(con);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

运行结果是：
1.5完美升级之后的结果

停止线程

stop方法已经结束；

那么如何停止线程？
只有一种。run方法结束。
开启多线程运行的时候，运行代码通常都是循环结构。
只要控制住循环，就可以让run方法结束，也就是线程结束。

下面有一个事例，停止线程的方法演示：

//停止线程
//利用的是让run方法结束的原理

class StopThread implements Runnable
{
    private boolean flag = true;
    public void run()
    {
        while (flag)//run方法里边有一个while循环，循环判断语句是flag
        {
            System.out.println(Thread.currentThread().getName()+"....run");
        }
    }
    public void changeFlag()//改变flag的值的方法
    {
        flag = false;

    }
}
public class StopThreadDemo {
    public static void main(String[] args) 
    {
        StopThread st = new StopThread();
        Thread t0 = new Thread(st);
        Thread t1 = new Thread(st);
        t0.start();//开启两个线程
        t1.start();

        int num = 0;//在主线程也开一个循环，三个线程同时进行
        while (true)
        {
            if (num++ == 60)
            {
                st.changeFlag();//这里修改掉flag的值，将flag的值变为假，
                                //当自定义的两个线程再判断的时候while不满足条件，run方法结束
                                //也就表示线程结束
                break;          //主线程也跳出循环，程序结束
            }
            System.out.println(Thread.currentThread().getName()+"..."+num);
        }
    }
}

运行结果为：

停止线程运行事例

实验结果可以看出，自定义线程和主线程交替运行，当main函数执行到60的时候，程序自动停止，也就是说这里线程自己停止了。

但是注意,有一种特殊情况用这种方法程序是停不下来的。
当线程处于了冻结状态
就不会读取到标记，那么线程就不会结束。

//停止线程

class StopThread implements Runnable
{
    private boolean flag = true;
    public synchronized  void run()//将函数变成同步函数
    {
        while (flag)
        {
            try
            {
                wait();//函数中加上wait方法，线程进来之后就冻结了。然后到主线程执行完，这两个自定义线程也醒不过来。
            }
            catch (InterruptedException e)
            {
                System.out.println(Thread.currentThread().getName()+"....Exception");
            }
            System.out.println(Thread.currentThread().getName()+"....run");
        }
    }
    public void changeFlag()
    {
        flag = false;

    }
}
public class StopThreadDemo {
    public static void main(String[] args) 
    {
        StopThread st = new StopThread();
        Thread t0 = new Thread(st);
        Thread t1 = new Thread(st);
        t0.start();
        t1.start();

        int num = 0;
        while (true)
        {
            if (num++ == 60)
            {
                st.changeFlag();
                break;          
            }
            System.out.println(Thread.currentThread().getName()+"..."+num);
        }
    }
}

运行结果：程序没有停下来。

停止线程2

这是为什么呢？

因为线程0进去判断为真，就冻结了，线程1进去也是冻结了，一直到主函数执行完都没有唤醒他们的语句，所以线程一直挂在那里，程序结束不了。

怎样解决呢？

查阅API文档，知道Thread类中有一个interrupt方法:
api

该方法可以将处于冻结状态的线程强制恢复到运行状态中来，但是会抛出异常，这就是中断异常。

具体应用方法看代码：

//停止线程

class StopThread implements Runnable
{
    private boolean flag = true;
    public synchronized  void run()
    {
        while (flag)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                System.out.println(Thread.currentThread().getName()+"....Exception");
                flag = false;//清除休眠之后，为了不再让线程继续休眠，将flag的值改为假。
                            //当该线程再次回来判断的时候，不符合条件，线程结束。
            }
            System.out.println(Thread.currentThread().getName()+"....run");
        }
    }
    public void changeFlag()
    {
        flag = false;

    }
}
public class StopThreadDemo {
    public static void main(String[] args) 
    {
        StopThread st = new StopThread();
        Thread t0 = new Thread(st);
        Thread t1 = new Thread(st);
        t0.start();
        t1.start();

        int num = 0;
        while (true)
        {
            if (num++ == 60)
            {
                //当num为60的时候，将线程强制清除休眠状态，让他继续执行。
                t0.interrupt();
                t1.interrupt();
                break;          
            }
            System.out.println(Thread.currentThread().getName()+"..."+num);
        }
        System.out.println("over");
    }
}

运行结果：线程可以停止。
通过线程中断来停止线程

守护线程

线程其实有前台线程和后台线程之分，
标记守护的线程就是后台线程，不标记的就是前台线程。

前台（守护）线程和后台线程在启动和运行上没有区别，在结束时，如果前台线程结束了，后台线程自动结束。
也就是说，当程序执行的只剩下后台线程了，Java虚拟机退出。

还是上边的例子：使用守护线程

//守护线程的用法

class StopThread implements Runnable
{
    private boolean flag = true;
    public void run()
    {
        while (flag)
        {
            System.out.println(Thread.currentThread().getName()+"....run");
        }
    }
    public void changeFlag()
    {
        flag = false;

    }
}
public class StopThreadDemo {
    public static void main(String[] args) 
    {
        StopThread st = new StopThread();
        Thread t0 = new Thread(st);
        Thread t1 = new Thread(st);
        //在启动前将线程标记为守护线程。用setDaemon方法
        t0.setDaemon(true);
        t1.setDaemon(true);

        t0.start();
        t1.start();

        int num = 0;
        while (true)
        {
            if (num++ == 60)
            {
                break;//这里break,表明主线程结束，其他两个守护线程就全都关掉了，程序结束         
            }
            System.out.println(Thread.currentThread().getName()+"..."+num);
        }
    }
}

运行结果，不用停止线程，只要主线程结束运行，其他线程就全都结束了

守护线程的例子

join方法

等待该线程终止；

当A线程执行到了B线程的.join()方法时，A就会等待，等线程B都执行完，A才会执行。

join可以用来临时加入线程。

通过例子来看：

//join方法，等待该线程结束


class Demo implements Runnable
{
    public void run()
    {
        for (int x = 0;x<70 ;x++ )
        {
            System.out.println(Thread.currentThread().getName()+"...."+x);
        }
    }
}
public class JoinDemo {
    public static void main(String[] args) throws InterruptedException
    {
        Demo d = new Demo();
        Thread t0 = new Thread(d);
        Thread t1 = new Thread(d);
        t0.start();//线程0开启（主线程开启了线程0）
        t0.join();//等待0线程结束（执行权给了线程0）
        t1.start();//开启线程1（接下来就是线程1和主线程交替运行）

        for (int x = 0;x<80 ;x++ )
        {
            System.out.println(".....main"+x);
        }

        System.out.println("over");
    }
}

运行结果是：等到线程0全部运行完，线程1和主线程才交替运行：

join方法等待运行事例

那么当我将join方法换一个位置之后呢？

//join方法，等待该线程结束


class Demo implements Runnable
{
    public void run()
    {
        for (int x = 0;x<70 ;x++ )
        {
            System.out.println(Thread.currentThread().getName()+"...."+x);
        }
    }
}
public class JoinDemo {
    public static void main(String[] args) throws InterruptedException
    {
        Demo d = new Demo();
        Thread t0 = new Thread(d);
        Thread t1 = new Thread(d);
        t0.start();
        t1.start();//主线程开启了两个线程。

        t0.join();//等待0线程执行完，主线程才能继续往下走，
                    //这个时候一共存在的有两个线程，所以是线程0和线程1交替执行
                    //等到线程0结束（线程1可以不结束）主线程才会继续执行下去。
        for (int x = 0;x<80 ;x++ )
        {
            System.out.println(".....main"+x);
        }

        System.out.println("over");
    }
}

运行结果为：

join等待事例2

Thread类中的其他方法

Thread类重写了Object中的toString方法

//toString方法查看优先级，setPriority方法设置优先级


class Demo implements Runnable
{
    public void run()
    {
        for (int x = 0;x<70 ;x++ )
        {
            System.out.println(Thread.currentThread().toString()+"...."+x);
        }
    }
}
public class JoinDemo {
    public static void main(String[] args) throws InterruptedException
    {
        Demo d = new Demo();
        Thread t0 = new Thread(d);
        Thread t1 = new Thread(d);
        t0.start();
        t1.start();
    }
}

运行结果是：
toString方法

由图上可以看出，toString方法显示的内容（荧光笔划住的内容）依次是：线程名称，优先级（默认都为5）线程组（本线程由谁开启的线程组就是谁的）

那么问题来了，怎么样修改线程的优先级呢？

//toString方法查看优先级，setPriority方法设置优先级
//优先级10最大，1最小


class Demo implements Runnable
{
    public void run()
    {
        for (int x = 0;x<70 ;x++ )
        {
            System.out.println(Thread.currentThread().toString()+"...."+x);
        }
    }
}
public class JoinDemo {
    public static void main(String[] args) throws InterruptedException
    {
        Demo d = new Demo();
        Thread t0 = new Thread(d);
        Thread t1 = new Thread(d);
        t0.setPriority(1);//利用传入int类型的值得方式传入优先值
        t1.setPriority(Thread.MAX_PRIORITY);//利用常量值得方式传入优先值
        t0.start();
        t1.start();
    }
}

运行结果：
优先值设定运行结果

yield方法的使用

暂停当前正在执行的线程，执行其他线程，
这个可以干什么呢？两个线程可以交替的执行。因为暂停只是暂时的。
但交替执行也是不确定的，因为暂停一下不能保证一定回去执行另外一个线程。

//yield方法的使用
class Demo implements Runnable
{
    public void run()
    {
        for (int x = 0;x<10 ;x++ )
        {
            System.out.println(Thread.currentThread().toString()+"...."+x);
            Thread.yield();//线程执行到这里的时候暂停一下，去执行其他的线程。
        }
    }
}
public class JoinDemo {
    public static void main(String[] args) throws InterruptedException
    {
        Demo d = new Demo();
        Thread t0 = new Thread(d);
        Thread t1 = new Thread(d);
        t0.start();
        t1.start();
    }
}

运行结果：
yield方法的使用

那么在实际开发中怎么写线程呢？

比如说我要三个for循环语句同时执行，

public class ThreadTest {
    public static void main(String[] args) 
    {
        new Thread()
        {
            public void run()
            {
                for (int x = 0;x<30 ;x++ )
                {
                    System.out.println("Thread..."+x);
                }
            }
        }.start();
        Runnable r = new Runnable()
        {
            public void run()
            {
                for (int x = 0;x<30 ;x++ )
                {
                    System.out.println("Runnable..."+x);
                }
            }
        };
        new Thread(r).start();
        for (int x = 0;x<30 ;x++ )
        {
            System.out.println("main..."+x);
        }
    }
}

运行结果：
实际开发创建线程用的代码

下山打老虎◆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
守护进程和多线程的创建和管理
02-13
一点学习笔记 参考了B站：https://www.bilibili.com/video/BV17h411s7Sf 如有不对的地方希望大家指正，谢谢！
java主线程结束和子线程结束之间的关系
热门推荐
aty
11-21 1万+
最近在和同事讨论java主线程和子线程之间的关系，自己也到网上搜索了下，发现各种答案都有，有些还是互相矛盾的。经过测试自己得出以下几个结论，跟大家分享下，如果有错误，欢迎大牛指正，帮助我这只小菜鸟。废话不多说，直接上结论： (一)Main线程是个非守护线程，不能设置成守护线程。               这是因为，main线程是由java虚拟机在启动的时候创建的。main方法开始执行的时候，
java线程之间的通信(等待/通知机制)
不能说的秘密的博客
03-13 7041
线程开始运行,拥有自己的栈空间，就如同一个脚本一样，按照代码一步步的执行直到终止。但是，每个运行中的线程，如果仅仅是孤立地运行，那么没有太大的价值，但如果多个线程能够相互配合完成工作，这将会带来巨大的价值。
当main方法中只有守护线程时，当main方法执行完毕后守护线程就死亡
yq2013101942的博客
04-15 2030
当main方法中只有守护线程时，当main方法执行完毕后守护线程就死亡。因为main线程执行完了后进程中就没有非守护线程了，从而进程也就终止了实例代码如下：运行结果为：由此可见：进程的终止决定于是否存在用户线程，守护线程 的终止决定于进程是否终止...
Java【多线程知识总结(2)】调用setDaemon(true)变成后台线程
javazhuanzai的专栏
02-01 307
====================================================== 注：本文源代码点此下载 ====================================================== /* 如果我们对某个线程对象在启动(调用start方法)之前调用了setdaemon(true)方法,这个线程就变成了 后台线程.对java程
黑马程序员——>第十二天<多线程(线程间通信-守护线程)>
orchid_yong的专栏
04-11 469
-------android培训、java培训、期待与您交流------- 01多线程(线程间通信-示例代码)   线程间通信：我们有一堆资源，a线程在往里边存数据，b线程在往外面取数据，这一进一出在同时运行，这就涉及到多线程。这两个线程运行代码不一致，一个负责往里边存数据，另一个往外边拿数据。所以动作不一致，就代表着有两个run方法来存放，两个run方法存放在两个类当中。 Input  资
Java多线程详解
01-20
文章目录1、进程与线程2、创建多线程2.1、继承Thread类2.2、实现Runnable接口2.3、使用匿名内部类实现2.4、实现Runnable接口的好处2.5、...守护线程4.3、休眠线程5、线程安全与线程同步5.1、安全问题5.2、解决方案一...
java—多线程的通信、生产者与消费者模式
12-21
isDaemon 判断是否为守护线程。 run方法是不能用synchronized修饰，他是继承来的，不能改变其结构，而且，如果run方法加了synchronized，就变成单线程了，就没有并发了。 只要不是静态的同步方法，同步方法默认的...
用qt实现的程序守护进程程序
09-07
可设置udp通信端口。 可设置超时次数。 自动记录已重启次数。 自动记录最后一次重启时间。 是否需要重新刷新桌面。 可重置当前重启次数和最后重启时间。 自动隐藏的托盘运行或者后台运行。 提供界面设置程序名称已经...
.NET 事件总线，简化项目、类库、线程、服务等之间的通信，代码更少，质量更好 ‎
最新发布
05-28
.NET 事件总线，简化项目、类库、线程、服务等之间的通信，代码更少，质量更好。‎特性（简化组件之间通信,支持事件监视器，支持动作执行器，支持自定义消息存储组件，支持自定义策略执行，支持单消费、多消费消息，...
Java基础——异常及处理方法
12345~
06-20 965
什么是异常？让我们先运行一段代码来理解 class Demo { int chuFa(int x,int y)//这是一个除法运算 { return x/y; } } public class ExceptionDemo { public static v
Java基础——IO流（四）
12345~
08-07 774
序列化对象将堆内存中的东西（对象）写到硬盘中ObjectOutputStream(OutputStream)中的writeObject方法可以将对象写入到硬盘中来 ObjectInputStream(InputStream)中的readObject方法可以将硬盘中的对象读取出来。先上手写程序： 先定义一个Per
Java基础——GUI概述
12345~
08-08 733
GUI图形用户界面GUI用户图形接口：用图形的方式，来显示计算机操作的界面，这样更方便更直观CLI命令行用户接口：就是常见的dos命令行操作，需要记忆一些常用的命令，操作不直观java为GUI提供的对象都存在java.Awt和javax.Swing两个包中Awt和Swing java.Awt抽象窗口工具包，需要调用
Java基础——其他类对象，IO流
12345~
07-30 729
System类System：类中的方法和属性都是静态的。 out：标准输出，默认是控制台 in ：标准输入，默认键盘描述系统的一些信息。获取系统属性信息：Propertise getPropertises();//获取系统信息的方法演示 import java.util.*; public class Syst
Java基础——String类、StringBuffer、Integer
12345~
07-12 678
String概述凡是带”“的都是String的实例对象。String s1 = "abc";s1是一个类类型变量，“abc”是一个对象。 字符串的最大特点就是，一旦被初始化就不可以被改变。 那么：String s1 = "abc"; s1 = "kk";这时候打印s1的值是kk; 这是为什么呢？不是说字符串一
Java基础——包
12345~
06-22 634
包package 什么是包？ 用来对类文件进行分类管理的，当类的内容不一样，但名称一样时，在同一个文件夹下不能保存同一个类文件，这个时候需要对类文件进行分类管理，将一个功能的所有class文件封装到一个文件夹中，这个文件夹就是包。 包也是一种封装形式，Java中包的出现，使不同的包中可以有相同名称的
Java基础——线程（一）
12345~
06-27 613
线程 进程：正在执行中的程序。每一个进程执行，都有一个执行的顺序，该顺序就是一个执行路径，或者叫一个控制单元。 线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。 简单一点来说进程和线程的关系，打开任务管理器可以看到很多正在执行的程序，每一个正在执行的程序就是进程， 而比如说迅雷下载数据的时候，会开辟
Java基础——集合框架（一）
12345~
07-14 586
集合类 为什么出现集合类？ 面向对象语言对事物的体现都是以对象形式存在的，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式 数组和集合类同是容器，有何不同？ 数组虽然也可以存储对象，但是长度是固定的。集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。 集合类的特点
jvm的守护线程突然暴增，什么原因
03-25
3. 网络超时：如果应用程序中存在网络通信，并且网络超时时间设置不当，也可能导致守护线程暴增。 4. 代码中存在资源泄漏：如果代码中存在资源泄漏，如文件句柄、数据库连接等，也可能导致守护线程暴增。 5. 配置...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值