Thread线程学习

最新推荐文章于 2022-06-18 07:13:52 发布
最新推荐文章于 2022-06-18 07:13:52 发布
阅读量155 收藏
点赞数
分类专栏： Java练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39996256/article/details/90518848
版权

在这里插入图片描述
线程概念：
在这里插入图片描述
线程创建的三种方式：

  1. 继承Thread类诚谢run方法
  2. 实现Runnable接口
  3. 实现Callable接口
    继承Thread类，重写run方法：
public class ThreadStart02 extends Thread {
    private String url;
    private String name;

    public ThreadStart02(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public void run(){
        WebDownLoader wd=new WebDownLoader();
        wd.downLoader(url,name);
        System.out.println(name);
    }

    public static void main(String[] args) {
        ThreadStart02 t1=new ThreadStart02("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1558614086192&di=6f4bac47d0efe87d00a0bdd2d56c01e1&imgtype=0&src=http%3A%2F%2Fpic32.nipic.com%2F20130823%2F13339320_183302468194_2.jpg","first.jpg");
        ThreadStart02 t2=new ThreadStart02("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1558614086192&di=50912f0854a71471859254a6c91c1a33&imgtype=0&src=http%3A%2F%2Fk.zol-img.com.cn%2Fsjbbs%2F7692%2Fa7691515_s.jpg","dog.jpg");
        ThreadStart02 t3=new ThreadStart02("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1558614086192&di=b6c27e363372754becd7ac9489b2e7cd&imgtype=0&src=http%3A%2F%2Fpic40.nipic.com%2F20140412%2F18428321_144447597175_2.jpg","three.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}

实现Runnable接口

/**
 * 推荐使用接口，避免单继承的局限性
 * 方便共享资源
 */
public class ThreadStart04 implements Runnable {
    private String url;
    private String name;

    public ThreadStart04(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public void run(){
        WebDownLoader wd=new WebDownLoader();
        wd.downLoader(url,name);
        System.out.println(name);
    }

    public static void main(String[] args) {
        ThreadStart04 t1=new ThreadStart04("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1558614086192&di=6f4bac47d0efe87d00a0bdd2d56c01e1&imgtype=0&src=http%3A%2F%2Fpic32.nipic.com%2F20130823%2F13339320_183302468194_2.jpg","first.jpg");
        ThreadStart04 t2=new ThreadStart04("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1558614086192&di=50912f0854a71471859254a6c91c1a33&imgtype=0&src=http%3A%2F%2Fk.zol-img.com.cn%2Fsjbbs%2F7692%2Fa7691515_s.jpg","dog.jpg");
        ThreadStart04 t3=new ThreadStart04("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1558614086192&di=b6c27e363372754becd7ac9489b2e7cd&imgtype=0&src=http%3A%2F%2Fpic40.nipic.com%2F20140412%2F18428321_144447597175_2.jpg","three.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
    }
}

赛跑代码：

/**
 * 模拟归途赛跑
 */
public class Reacer implements Runnable {
    private static String winner;
    @Override
    public void run() {
        for(int steps=0;steps<=100;steps++){
            if(Thread.currentThread().getName().equals("兔子") && steps%10==0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"--->"+steps);
            //比赛是否结束
            boolean flag=gameOver(steps);
            if (flag) {
                break;
            }
        }
    }
    private boolean gameOver(int steps){
        if(winner!=null){
            return true;
        }else{
            if(steps==100){
                winner=Thread.currentThread().getName();
                System.out.println("winner==>"+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Reacer racer=new Reacer();
        new Thread(racer,"兔子").start();
        new Thread(racer,"乌龟").start();
    }
}
Callable学习：
public class Reacer1 implements Callable<Integer> {
    private static String winner;
    @Override
    public Integer call() throws Exception {
        for(int steps=0;steps<=100;steps++){
            if(Thread.currentThread().getName().equals("pool-1-thread-1") && steps%10==0){
                Thread.sleep(100);
            }
            System.out.println(Thread.currentThread().getName()+"--->"+steps);
            //比赛是否结束
            boolean flag=gameOver(steps);
            if (flag) {
                return steps;
            }
        }
        return null;
    }
    private boolean gameOver(int steps){
        if(winner!=null){
            return true;
        }else{
            if(steps==100){
                winner=Thread.currentThread().getName();
                System.out.println("winner==>"+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Reacer1 racer=new Reacer1();
        ExecutorService ser= Executors.newFixedThreadPool(2);
        //开始执行
        Future<Integer> result1=ser.submit(racer);
        Future<Integer> result2=ser.submit(racer);

        int r1=result1.get();
        int r2=result2.get();
        System.out.println("r1:"+r1+" r2:"+r2);
        ser.shutdown();
    }
}

代理模式：

/**
 * 静态代理
 * 接口：
 * 1，真是角色
 * 2，代理角色
 */
public class StaticProxy {
    public static void main(String[] args) {
        new WeddingCompany(new You()).happyMarry();
    }
}
interface Marry{
    void happyMarry();
}
class You implements Marry{

    @Override
    public void happyMarry() {
        System.out.println("you and 唱歌终于奔月了。。。。。");
    }
}
class WeddingCompany implements Marry{
    private Marry target;
    public WeddingCompany(Marry target){
        this.target=target;
    }
    @Override
    public void happyMarry() {
        ready();
        this.target.happyMarry();
        after();
    }

    private void ready() {
        System.out.println("布置桌子");
    }
    public void after(){
        System.out.println("结婚完毕");
    }

}

lamda表达式：
避免内部类定义过多，实质属于函数式变成的概念

public class LamdaTest05 {
    public static void main(String[] args) {
        new Thread(()->{
            for(int i=0;i<100;i++){
                System.out.println("一遍学习");
            }

        }).start();

        new Thread(()->{
            for(int i=0;i<100;i++){
                System.out.println("一遍泪流满面");
            }
        }).start();
    }
}

线程状态：
在这里插入图片描述
在这里插入图片描述
常见的线程方法：

线程的停止：
在这里插入图片描述
sleep:
1,指定当前线程阻塞的毫秒数，占有资源
2，存在中断异常InterruptedException
2,时间到后到就绪态

public class BlockStatus03 {
    public static void main(String[] args) throws InterruptedException {
        //倒数是个数。一秒一个
        Date dateTime=new Date(System.currentTimeMillis()+1000*10);
        Long end=dateTime.getTime();
        while(true){
            System.out.println(new SimpleDateFormat("mm:ss").format(dateTime));
            Thread.sleep(1000);
            dateTime=new Date(dateTime.getTime()-1000);
            if(end-10000>=dateTime.getTime()){
                break;
            }
        }
    }
    public static void test() throws InterruptedException {
        int num=10;
        while(true){
            Thread.sleep(1000);
            System.out.println(num--);
        }
    }
}

就绪状态：
1，start()方法
2，阻塞接触
3，yield（）方法
4，jvm切换
运行状态：running，cpu进行控制，一般为时间分配时间片，开始运行，可以看下os的调度
阻塞状态：
1，sleep 资源占有，然后谁卖你
2，join 在那个方法，那个方法阻塞
3，wait
4，io的read 和write犯法

public class AllState {
    public static void main(String[] args) {
        Thread t=new Thread(()->{
            for(int i=0;i<5;i++){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(".....");
            }
        });
        Thread.State state=t.getState();
        System.out.println(state);

        t.start();
        state=t.getState();
        System.out.println(state);

        while(state!=Thread.State.TERMINATED){
            int num=Thread.activeCount();
            if(num==1){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state=t.getState();
            System.out.println(state);
        }
        state=t.getState();
        System.out.println(state);

    }
}

priority:优先级

/**
 * 新城优先级
 * 概率：知识先后执行的概率
 */
public class PriorityTest01 {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getPriority());
        MyPriority mp=new MyPriority();

        Thread t=new Thread(mp,"address");
        Thread t1=new Thread(mp,"NIKE");
        Thread t2=new Thread(mp,"回力");
        Thread t3=new Thread(mp,"361");
        Thread t4=new Thread(mp,"李宁");
        //设置优先级再启动之前
        t.setPriority(Thread.MAX_PRIORITY);
        t1.setPriority(Thread.MAX_PRIORITY);
        t2.setPriority(Thread.NORM_PRIORITY);
        t3.setPriority(Thread.MIN_PRIORITY);
        t4.setPriority(Thread.MIN_PRIORITY);
        t.start();
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
class MyPriority implements  Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
        Thread.yield();
    }
}

线程分配

1，分为用户线程和守护线程
2，虚拟机必须确保用户线程执行完毕
‘3，虚拟机不用等待守护线程执行完毕

 * 守护线程
 * 是为用户线程服务的，JVM停止，不用等待守护线程执行完毕
 * 默认都是用户用户线程，jvm等待所有的用户线程执行完毕
 */
public class DaemonTest01 {
    public static void main(String[] args) {
        God god=new God();
        You you=new You();
        Thread t=new Thread(god);
        t.setDaemon(true);
        t.start();
        new Thread(you).start();

    }
}
class You implements Runnable{
    public void run(){
        for(int i=0;i<365*100;i++){
            System.out.println("happy life-----");
        }
        System.out.println("oooooo");
    }
}
class God implements  Runnable{
    public void run(){
        for(;true;){
            System.out.println("bresss you-----");
        }
    }
}

在这里插入图片描述’常用方法示例：

/**
 * isAlive：线程是否还活着
 * currentThread 当前线程
 * setName 设置名称：代理名称
 * 程序猿的劳斯莱斯
 */
public class InfoTest {
    public static void main(String[] args) throws InterruptedException {
        System.out.println(Thread.currentThread().isAlive());

        //设置名称：真是角色+代理角色
        myInfo info=new myInfo("站冬季");
        Thread t=new Thread(info);
        t.setName("公鸡");
        t.start();
        Thread.sleep(1000);
        System.out.println(t.isAlive());
    }
}
class myInfo implements Runnable{
    private String name;

    public myInfo(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+name);
    }
}

线程同步：
synchronized,并发控制

/**
 * 取钱线程不安全
 */
public class UnsafeTest02 {
    public static void main(String[] args) {
        Account account=new Account(100,"结婚礼金");
        Drawing you=new Drawing(account,80,"可悲的你");
        Drawing wife=new Drawing(account,90,"女朋友");
        you.start();
        wife.start();

    }
}
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
class Drawing extends Thread{
    Account account;//账户
    int drawingMoney;//区签署
    int drawTotal;//取钱总数

    public Drawing(Account account, int drawingMoney,String name) {
        super(name);
        this.drawingMoney = drawingMoney;
        this.account = account;
    }

    @Override
    public void run() {
        if(account.money-drawingMoney<0){
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money-=drawingMoney;
        drawTotal+=drawingMoney;
        System.out.println(this.getName()+"-->账户余额为"+account.money);
        System.out.println(this.getName()+"-->取钱总额为"+drawTotal);
    }
}
常规容易出现问题，不可避免，
女朋友-->账户余额为-70
女朋友-->取钱总额为90
可悲的你-->账户余额为-70
可悲的你-->取钱总额为80

并发原因：
1，同一个对象呗多个线程同时操作
线程同步 ：当两个或两个以上线程访问同一资源时，需要某种方式来确保资源在某一时刻只被一个线程 使用。
1，队列
2，锁机制
同步监视器
• synchronized (obj){ }中的obj称为同步监视器
• 同步代码块中同步监视器可以是任何对象，但是推荐使用共享资源作为同步监视器
• 同步方法中无需指定同步监视器，因为同步方法的同步监视器是this，也就是该对象本事

同步监视器的执行过程
• 第一个线程访问，锁定同步监视器，执行其中代码
• 第二个线程访问，发现同步监视器被锁定，无法访问
• 第一个线程访问完毕，解锁同步监视器
• 第二个线程访问，发现同步监视器未锁，锁定并访问
synchronized：锁对象的资源，即this

/**
 * 数据有负数或者重复
 *
 */
public class SynTest01 {
    public static void main(String[] args) {
        SynTest0112306 web=new SynTest0112306();
        new Thread(web,"码畜").start();
        new Thread(web,"码农").start();
        new Thread(web,"码皇").start();
    }
}

class SynTest0112306 implements Runnable {
    private int ticketsNum=10;
    private boolean flag=true;
    @Override
    public void run() {
        while(flag){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            test();
        }

    }
    public synchronized void test(){
        if(ticketsNum<=0){
            flag=false;
            return;
        }
        /**
         * 模拟网络延时
         */
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"------>"+ticketsNum--);
    }

}

同步代码块：

/**
 * 取钱线程不安全
 */
public class SynTest03 {
    public static void main(String[] args) {
        Account2 account=new Account2(100,"结婚礼金");
        Drawing2 you=new Drawing2(account,80,"可悲的你");
        Drawing2 wife=new Drawing2(account,90,"女朋友");
        you.start();
        wife.start();

    }
}

class Account2{
    int money;
    String name;

    public Account2(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing2 extends Thread{
    Account2 account;//账户
    int drawingMoney;//去签署
    int drawTotal;//取钱总数

    public Drawing2(Account2 account, int drawingMoney, String name) {
        super(name);
        this.drawingMoney = drawingMoney;
        this.account = account;
    }

    @Override
    public void run() {
        test();
    }
    //目标锁定不确定，这里不应爱锁this
    public synchronized void test(){
        if(account.money-drawingMoney<0){
            return;
        }
        synchronized (account){
            if(account.money-drawingMoney<0){
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money-=drawingMoney;
            drawTotal+=drawingMoney;
            System.out.println(this.getName()+"-->账户余额为"+account.money);
            System.out.println(this.getName()+"-->取钱总额为"+drawTotal);
        }
    }
}

synchronized:

package syn;

/**
 * 取钱线程不安全
 */
public class SynTest03 {
    public static void main(String[] args) {
        Account2 account=new Account2(100,"结婚礼金");
        Drawing2 you=new Drawing2(account,80,"可悲的你");
        Drawing2 wife=new Drawing2(account,90,"女朋友");
        you.start();
        wife.start();

    }
}

class Account2{
    int money;
    String name;

    public Account2(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

class Drawing2 extends Thread{
    Account2 account;//账户
    int drawingMoney;//去签署
    int drawTotal;//取钱总数

    public Drawing2(Account2 account, int drawingMoney, String name) {
        super(name);
        this.drawingMoney = drawingMoney;
        this.account = account;
    }

    @Override
    public void run() {
        test();
    }
    //目标锁定不确定，这里不应爱锁this
    public void test(){
        if(account.money<=0){
            return;
        }
        synchronized (account){
            if(account.money-drawingMoney<0){
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money-=drawingMoney;
            drawTotal+=drawingMoney;
            System.out.println(this.getName()+"-->账户余额为"+account.money);
            System.out.println(this.getName()+"-->取钱总额为"+drawTotal);
        }
    }
}

List的方法：

import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 操作容器:线程安全
 */
public class SynContainer {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String> lists=new CopyOnWriteArrayList<>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                lists.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(2000);
        System.out.println(lists.size());
    }
}

思索：多个线程各自占有共享资源，相互等待其他线程的资源释放，才能继续进行，导致多个线程等待对方释放资源，都停止执行，当一个同步块同时拥有两个以上的对象的锁的同时，就有可能发生思索问题。
1，问题的发生条件为锁套锁，即出现多个锁

/**
 * @author lsd
 * 思索
 */
public class DeadLock {
    public static void main(String[] args) {
        Markup g1=new Markup(1,"大牙");
        Markup g2=new Markup(0,"王菲");
        g1.start();
        g2.start();

    }
}
class Lipstick{

}
class Mirror{

}
class Markup extends Thread{
    static Lipstick lipstick=new Lipstick();
    static Mirror mirror=new Mirror();
    int choice;
    String girl;
    public Markup(int choice,String girl) {
        this.choice = choice;
        this.girl=girl;
    }
    //相互持有对方的对象锁
    public void markup(){
        if(choice==0){
            synchronized (lipstick){
                System.out.println(this.girl+"获得口红");
                //一秒后想拥有镜子的锁
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (mirror){
                System.out.println(this.girl+"获得镜子");
            }
        }else{
            synchronized (mirror){
                System.out.println(this.girl+"获得镜子");
                //一秒后想拥有镜子的锁
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (lipstick){
                System.out.println(this.girl+"获得口红");
            }
        }
    }

    @Override
    public void run(){
        markup();
    }
}

线程的写作：
生产者消费者模型：
在这里插入图片描述
在这里插入图片描述
管程法：解耦，缓冲区，互相不关联
3个角色：生产者，消费者，并发容器
信号灯法：

/**
 * 生产者消费者实现方式一：信号灯
 */
public class CodeTest02 {
    public static void main(String[] args) {
        Tv con=new Tv();
        new Player(con).start();
        new Watcher(con).start();
    }
}

//生产者 演员
class Player extends  Thread{
    Tv tv;

    public Player(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            if (i % 2 == 0) {
                try {
                    this.tv.play("奇葩说");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                try {
                    this.tv.play("太污了，喝瓶礼拜嘻嘻最");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//消费者 观众
class Watcher extends Thread{
    Tv tv;

    public Watcher(Tv tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            if (i % 2 == 0) {
                try {
                    this.tv.watch();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                try {
                    this.tv.watch();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
//同一个资源 电视
class Tv{
    String voice;
    //信号灯 t演员表演 观众等待
    boolean flag=true;
    public synchronized void play(String voice) throws InterruptedException {
        //演员等待
        if(!flag){
            this.wait();
        }
        System.out.println("表演了"+voice);
        this.voice=voice;
        this.notifyAll();
        this.flag=!this.flag;
    }
    public synchronized void watch() throws InterruptedException {
        //观众等待
        if(flag){
            this.wait();
        }
        System.out.println("听到了"+voice);
        this.notifyAll();
        //切换标志
        this.flag=!this.flag;
    }
}

管程法：

/**
 * 生产者消费者实现方式一：管程法
 */
public class CodeTest01 {
    public static void main(String[] args) {
        SynContainer con=new SynContainer();
        new Productor(con).start();
        new Comsumer(con).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer synContainer;

    public Productor(SynContainer synContainer) {
        this.synContainer = synContainer;
    }

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("生产第"+i+"个馒头");
            synContainer.push(new Steamedbun(i));
        }
    }
}
//消费者
class Comsumer extends  Thread{
    SynContainer synContainer;

    public Comsumer(SynContainer synContainer) {
        this.synContainer = synContainer;
    }
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println("消费第"+synContainer.pop().id+"个馒头");
        }
    }
}
//缓冲区
class SynContainer{
    Steamedbun[] bums=new Steamedbun[10];
    int count=0;//计数器
    //存储
    public synchronized void push(Steamedbun bun){
        //不能生产
        if(count==bums.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        bums[count]=bun;
        count++;
        this.notifyAll();
    }
    //获取
    public synchronized Steamedbun pop(){
        if(count==0){
            try {
                this.wait();//此时线程阻塞，生产者通知消费，线程阻塞
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Steamedbun bun=bums[count];
        this.notifyAll();
        return bun;
    }
}
//馒头
class Steamedbun{
    int id;

    public Steamedbun(int id) {
        this.id = id;
    }
}

任务定时调度：

import java.util.*;

public class MyTimerTest01 {
    public static void main(String[] args) {
        Timer timer=new Timer();
        Calendar c=new GregorianCalendar(2099,12,31,21,53,54);
        timer.schedule(new MyTask(),c.getTime(),1000);
    }
}
//任务类，多线程
class MyTask extends TimerTask {

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println("放松大脑，放松会");
        }
        System.out.println("------end-----");
    }
}

定时器调度：spring集成

/**
 * This Example will demonstrate how to start and shutdown the Quartz scheduler and how to schedule a job to run in
 * Quartz.
 * 
 * @author Bill Kratzer
 */
public class QuartzTest {

  public void run() throws Exception {
    Logger log = LoggerFactory.getLogger(QuartzTest.class);

    log.info("------- 初始化 ---------");

    // 1，创建Scheduler工厂
    SchedulerFactory sf = new StdSchedulerFactory();
    //2，从工厂中获取调度器
    Scheduler sched = sf.getScheduler();
    // 设置时间
    Date runTime = evenSecondDate(new Date());

    // 3，创建JobDetail
    JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();

    // 4.触发器
    Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startAt(runTime).withSchedule(simpleSchedule().withIntervalInSeconds(5).withRepeatCount(3)).build();


    // 5,注册任务和触发条件
    sched.scheduleJob(job, trigger);
    sched.start();

    log.info("------- 任务调度开始 -----------------");

    // wait long enough so that the scheduler as an opportunity to
    // run the job!
    log.info("------- 5秒之后调度. -------------");
    try {
      // 5秒后停止
      Thread.sleep(65L * 1000L);
    } catch (Exception e) {
      e.printStackTrace();
    }

    log.info("------- 结束调度 ---------------------");
    sched.shutdown(true);
  }

  public static void main(String[] args) throws Exception {

    QuartzTest example = new QuartzTest();
    example.run();

  }

}

HappenBefore:
写的代码可能没按照自己想要的顺序去执行。
在这里插入图片描述
在这里插入图片描述
执行顺序：
1，获取指令
2，解码翻译 寄存器取值
3，操作
4，写回寄存器

public class HappenBerore {
    private static int a=0;
    private static boolean flag=false;
    public static void main(String[] args) throws InterruptedException {
        for(int i=0;i<100;i++){
            a=0;
            flag=false;
            Thread t=new Thread(()->{
                a=1;
                flag=true;
            });

            Thread t2=new Thread(()->{
                if(flag){
                    a*=1;
                }
                if(a==0){
                    System.out.println("happen_before  "+a);
                }
            });
            t.start();
            t2.start();
            t.join();
            t2.join();
        }

    }
}

结果为：

happen_before  1
happen_before  0
happen_before  0
happen_before  0
happen_before  0

volatile:只保证同步的数据可见。
在这里插入图片描述

/**
 * 用于保证数据的同步，也就是可见性
 * @author lsd
 */
public class VolatileTest {
    private volatile static int num=0;

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while(num==0){
            }
        }).start();

        Thread.sleep(1000);
        num=1;
    }
}

单例模式：

/**
 * 单例模式：套路，多线程环境下对外存在一个对象
 * 1，构造器私有化--》避免外部new构造器
 * 2，提供私有的静态属性--》存储对象的地址
 * 3，提供公共的静态方法--》获取属性
 */
public class DoubleCheckedLocking {
    //私有静态属性
    private volatile static DoubleCheckedLocking instance;
    //构造器私有化
    private DoubleCheckedLocking(){

    }

    public static DoubleCheckedLocking getInstance(){
        if(instance!=null){//避免不必要的
            return instance;
        }
        synchronized(DoubleCheckedLocking.class){
            if(null==instance){
                instance=new DoubleCheckedLocking();
                //开辟空间，初始化对象信息，返回对象的地址引用
            }
        }
        return  instance;
    }

    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(DoubleCheckedLocking.getInstance());
        }).start();
        System.out.println(DoubleCheckedLocking.getInstance());
    }
}

ThreadLocal:

在这里插入图片描述

/**
 * ThreadLocal：需要分析上下文环境，七点
 * 1，构造器，哪里调用就属于哪里
 */
public class ThreadLocalTest3 {
    private static ThreadLocal<Integer> threadLocal=ThreadLocal.withInitial(()->1);
    public static void main(String[] args) {
        new Thread(new MyRun()).start();
        new Thread(new MyRun()).start();
    }

    public static class MyRun implements  Runnable{
        public MyRun(){
            threadLocal.set(20);
            System.out.println(Thread.currentThread().getName()+"还剩下---->"+threadLocal.get());
        }
        @Override
        public void run() {
            Integer left=threadLocal.get();
            System.out.println(Thread.currentThread().getName()+"得到了---->"+left);
            threadLocal.set(left-1);
            System.out.println(Thread.currentThread().getName()+"还剩下---->"+threadLocal.get());
        }

    }
}
柳絮11
关注
专栏目录
error C2783: 无法为“T”推导 模板 参数
weixin_33712881的博客
09-20 1577
原则：“模板参数推导机制无法推导函数的返回值类型” 版本一： // 缺少<T> 参数 int n 对比第三个版本（ 缺少<T> 参数 T n) ！ 编译错误提示： 错误 1 error C2783: “T FibRecursion(int)”: 无法为“T”推导 模板 参数 c:\users\yi\documents\visual studi...
RT-Thread学习笔记——线程管理
Sanjay_Wu的博客
01-23 5114
前言 本文主要讲RT-Thread的线程管理，基于STM32L475VET5。学习RT-Thread的线程管理，实现线程的创建、多线程创建，线程的挂起与恢复等，过程中会涉及核对象容器概念，读者如果对RT-Thread的对象容器不了解，可先看《RT-Thread编程指南》的内核基础部分。 一、RT-Thread线程管理的功能特点 RT-Thread 线程管理的主要功能是对线程进行管理和调...
高级网络编程总结
东城西就
05-06 369
黑马程序员        ----------------------android培训、java培训 、期待与您交流！ ----------------------   1、        找到对方IP。 2、        数据库要发送到对方指定的应用程序上。为了标示这些应用程序，所以给这些网络应用程序都用数字进行标示。为了方便称呼这个数字，叫做端口。逻辑端口。 3、
ThreadX学习（2）——线程
weixin_43739110的博客
06-11 4887
ThreadX学习（2）——线程学习参考：ThreadX中的线程线程创建堆栈分配互斥锁线程优先级优先级反转优先级继承抢占阈值线程状态数据结构TCB就绪列表API 学习参考： 《Real-Time Embedded Multithreading: Using ThreadX and ARM》 安富莱_STM32-V7开发板ThreadX内核教程（V0.7） ThreadX中的线程 在ThreadX中，一般没有进程的概念，统称为线程。 关于调度器的实现细节，ThreadX可能是用汇编写的，没看懂。 T
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 42万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
RT-Thread 线程管理（学习笔记）
Super辉sir的博客
03-26 3504
本文参考自[野火EmbedFire]《RT-Thread内核实现与应用开发实战——基于STM32》，仅作为个人学习笔记。更详细的内容和步骤请查看原文（可到野火资料下载中心下载）
线程的学习-peak
peakr的博客
12-09 1471
线程的学习基本概念单线程多线程程序进程线程调度线程的状态新建状态就绪状态执行状态阻塞状态消亡状态JAVA的Thread线程类与Runnable接口1.利用Thread类的子类来创建线程用Runnable接口来创建线程线程的同步 基本概念 单线程 一个程序只有从头到尾的一条执行路径。 多线程 同一个进程同时存在几个执行体，按几条不同的执行路径同时工作。 程序 指含有指令和数据的文件。 进程 程序的执...
Python 多线程学习
Herishwater的博客
05-10 3535
前言 在爬虫学习的过程中，一旦爬取的数量过大，很容易带来效率问题，为了能够快速爬取我们想要的内容。为此我们可以使用多线程或者多进程来处理。 多线程和多进程是不一样的！一个是 threading 库，一个是 multiprocessing 库。而多线程 threading 在 Python 里面被称作鸡肋的存在！关于 Python 多线程有这样一句名言——“Python下多线程是鸡肋，推荐使用多进程...
RT-Thread学习笔记(7)：线程管理
BLBQ962464的博客
03-26 2614
本节笔记参考于：野火-《RT-Thread内核实现与应用开发实战》 以及RT线程管理线程基本概念线程调度器线程状态线程挂起函数线程恢复函数线程设计要点RT-Thread中程序运行的上下文包括：中断服务函数：线程：空闲线程：线程执行时间 线程基本概念 RT-Thread的线程可认为是一系列独立线程的集合。每个线程在自己的环境中运行。在任何时刻，只有一个线程得到运行，RT-Thread调度器决定运行哪个线程。调度器会不断启动、停止每一个线程，宏观看上去所有的线程都在同时在执行。作为线程，不需要对调度器的活动有所
创建rt_thread线程
RONG_YAO的博客
06-18 2041
目录系列文章目录一、SRAM静态内存1、定义线程函数2、创建线程栈3.主函数二、SRAM 动态内存1、动态内存来源2、动态创建线程总结第一章:将rt_thread移植到stm32第二章:创建rt_thread线程前言本章学习如何使用rt_thread创建线程 2、创建线程栈 线程的栈是一个全局数组。 线程的栈占用的是 MCU 内部的 RAM，当线程越多的时候，需要使用的 栈空间就越大，即需要使用的 RAM 空间就越多。 MCU支持多少个线程取决于RAM的大小。 3.主函数
Java实习生面试复习(五)：Thread线程学习
01-20
我是一名很普通的双非大三学生。接下来的几个月内，我将坚持写博客，输出知识的同时巩固自己的基础，记录自己的成长和锻炼自己，备战2021暑期实习面试！...线程的状态在 JDK 1.5 之后以枚举的方式被定义在 Thread 的源
C++ 线程学习，thread常用操作
最新发布
02-06
C++11标准引入了`<thread>`库，使得在C++中处理多线程变得标准化和简单化。本教程将深入探讨C++线程的常用操作，包括创建线程、线程同步、线程通信以及线程管理。 1. **线程创建** - `std::thread`构造函数：创建...
thread多线程学习记录
04-13
"thread多线程学习记录"这个标题表明我们将探讨Java中的线程处理，这部分内容可能涵盖了如何创建和管理线程、同步机制以及线程通信等方面。"狂神"是某位知名IT讲师的昵称，这暗示了我们学习的资源来源于他的视频教程...
python线程锁(thread)学习示例
12-25
复制代码 代码如下:# encoding: UTF-8import threadimport time# 一个用于在线程中执行的函数def func(): for i in range(5): print ‘func’ time.sleep(1) # 结束当前线程 # 这个方法与thread.exit_thread()...
Java基础巩固之线程学习
01-20
一、线程的学习 　线程是程序中执行单个任务的顺序的流程。 　线程创建的两种方式： 　1、继承Thread类 publicstaticvoidmain(String[]args) { //继承Thread类覆盖父类run方法 Threadthread=newThread() { ...
动态编译（JavaCompiler）
weixin_39996256的博客
06-03 6577
public class Demo01 { public static void main(String[] args) { JavaCompiler compiler= ToolProvider.getSystemJavaCompiler(); int result=compiler.run(null, null, null,"d:/myC/Hello...
手写web服务器（理解servlet和dispatcher和handler）
weixin_39996256的博客
05-31 1452
Server:服务器，用来创建ServerSocket，创建服务器，阻塞式创建线程 /** */ public class Server09 { private ServerSocket serverSocket; private boolean isRunning=false; public static void main(String[] args) { ...
脚本引擎（基础学习）
weixin_39996256的博客
06-03 1159
代码示例： /** * js脚本引擎 rahio * @author lsd */ public class Demo01 { public static void main(String[] args) throws ScriptException, NoSuchMethodException, FileNotFoundException { //获得脚本你引擎...
Exception异常
weixin_39996256的博客
05-16 390
java异常定义： try{ copyFile("d:/a.txx","e:/e.txt"); }catch (Exception e){ e.printStackTrace(); } 异常处理方式： 1，抛出异常：执行方法出现异常，则交给改异常的对象，停止当前执行路径，j交给java运行环境即JRE 2，补货...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值