Java 多线程的操作常见操作（Multithread operation）

package Main;
//

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

/**
 * Instructions(shuoming):
 * ：多线程的操作包括 联合线程、后台线程、线程的优先级、线程礼让、定时器和线程组.
 * ：
 * -联合线程调用join方法；即强制执行当前线程直到完毕，后再执行其他线程，强行把多通道变为一通道。
 * -后台线程（守护线程）是为其他线程提供服务，JVM的垃圾回收线程就是经典的后台线程实例。其生命周期随前台线程的死亡而死亡。
 * 用setDaemon（）方法置后台线程是一定要在启动之前实现设置好不能在线程已经启动后再更改。
 * 在任何主线程区域创建的线程称为其子线程并且前后线程属性与父线程相同。
 * -线程优先级高获得执行的机会越大（并不是越高越先执行），一般情况下有三个默认值 1、5、10（不能小于1或大于10）
 * -即当前想成对象提示调度器自己愿意让出CPU资源，但调度器可以自由忽略该提示。调用yield()方法即
 *  执行线程礼让，调用后线程对象进入就绪状态，所以完全有可能调用了yield后线程调度器又把它从新执行。
 * -在JDK的java.util包中提供了Timer类可以自行特定的任务，常用的有schedule(TimeTask,long delay,long period);
 *  和schedule(Timer task,long delay);
 * -ThreadGroup类表示线程组，可以对一组线程进行集中管理，用户在创建线程对象时可以通过构造器指定其所属线程组，
 *  Thread(ThreadGroup geroup，String name); ，如果A线程创建了B线程时没有为其设置线程分组，则默认加入创建者组，
 *  且一旦加入某线程组就不能更换直至死亡，中途也不能修改。当Java程序运行时，
 *  默认情况下JVM会创建一个名为main的线程组，在默认情况下所有的线程都在该组下。
 * @Attention(zhuyi！)： 1、sleep不释放同步监听锁wait则会释放同步监听锁。
 * 2、
 * 3、
 * 4、
 * 5、
 * 6、
 * @time：-2019/10/05
 * @role(shei)：-东方神祇（杨)
 * @modify(xiugai)：- -@time：-
 * -@role：-
 */
public class MultithreadOperation {
    public static void main(String[] args) throws InterruptedException {

 /*       //联合线程Test
        ThreadJoinDemo JD = new ThreadJoinDemo();
        for (int i = 0; i < 50; i++) {
            System.out.println("main线程：" + i);
            Thread.sleep(100);
            if (i == 10) {
                JD.start();
            }//启动线程：此时两个线程同时存在交替执行各自线程。
            if (i == 20) {
                JD.join();
            }//启动联合线程：此时接着start后面从一直霸占线程直到执行完才然main执行而不是交替执行。
        }*/


/*        //后台线程Test
        //System.out.println(Thread.currentThread().isDaemon());//查看当前线程是前是后
        BackstageThread BT = new BackstageThread();
        for (int i = 0; i < 15; i++) {
            System.out.println("main--"+i+"--"+BT.currentThread().isDaemon());
            Thread.sleep(100);
            if(i==10){
                BT.setDaemon(true);
                BT.start();
            }
        }*/


/*      //线程优先级Demo
        //int getPriority()获取优先级
        //void setPriority()设置优先级
        ThreadPriority TPG1 = new ThreadPriority("高优先级1");
            TPG1.setPriority(Thread.MIN_PRIORITY);
        ThreadPriority TPG2 = new ThreadPriority("高优先级2");
            TPG1.setPriority(2);
        ThreadPriority TPG3 = new ThreadPriority("高优先级3");
            TPG1.setPriority(3);
        ThreadPriority TPD1 = new ThreadPriority("低优先级1");
            TPD1.setPriority(Thread.NORM_PRIORITY);
        ThreadPriority TPD2 = new ThreadPriority("低优先级2");
            TPD2.setPriority(6);
        ThreadPriority TPD3 = new ThreadPriority("低优先级3");
            TPD3.setPriority(9);
        ThreadPriority TPD4 = new ThreadPriority("低优先级4");
            TPD4.setPriority(Thread.MAX_PRIORITY);

        TPG1.start();
        TPG2.start();
        TPG3.start();
        TPD1.start();
        TPD2.start();
        TPD3.start();
        TPD4.start();*/


    //线程礼让Test



  //定时器和线程组Test
    System.out.println("begin>>>");
    new Timer().schedule(new ThreadTimer(), 2000,100);
    Thread.sleep(2500);
    System.out.println("<<end>>");
    }
}

//联合线程Demo
class ThreadJoinDemo extends Thread {
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("ThreadJoin线程：" + i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//后台线程Demo
//Thread.currentThread().isDaemon()方法可以得出当前线程是否非后台线程
// 如果是Flase则是主线程（前台线程）否则为后台线程
class BackstageThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println(super.getName() + "--" + i + "--" + BackstageThread.currentThread().isDaemon());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//线程优先级Demo
//
class ThreadPriority extends Thread {
    public ThreadPriority(String name){
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 80; i++) {
            System.out.println(super.getName() + "--" + i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


//线程礼让Demo
class ThreadComity extends Thread{
    //yield方法和sleep方法类似：都能使当前处于运行状态的线程线程放弃CPU，把运行机会给其他线程。
    //他们的区别在于：
    //1、sleep方法给其他线程运行机会是不会考虑其他线程的优先级，yield方法只会给相同优先级或更高的级别的线程运行机会。
    //2、调用sleep方法后，线程会进入计时状态，而yield则会进入就绪状态。
}


//定时器Demo
class ThreadTimer extends TimerTask {

    @Override
    public void run() {
        System.out.println("你好师姐！");
        System.out.println(new Date().toLocaleString());
    }
}
//线程组Demo
class ThreadGroup extends Thread{

}


/**总结：
 *
 */

/* ------------------- 反爬声明o(*▽*)咻咻咻 --------------------

作者： 杨木发
版权声明：
本文为博主倾情原创文章，整篇转载请附上源文链接！

如果觉得本文对你有所收获，你的请评论点赞 与

合理优质的转发也将是鼓励支持我继续创作的动力，

更多精彩可百度搜索 杨木发 或：

个人网站： www.yangmufa.com ，

开源中国： https://my.oschina.net/yangmufa ，

Gitee： https://gitee.com/yangmufa ，

GitHub： https://github.com/yangmufa 。

坚持创作 善于总结 开源共享 高质进步。
------------------- 反爬声明o(*▽*)咻咻咻 -------------------- */