Java-多线程(一)

NO.1 多线程简介
1.多线程是CPU不断在执行程序之间切换，速率极快，
给人们造成的假象是所有程序是同时执行的。 其实在内部依然是一个个执行的。
2. JVM的启动是多线程的
//证明JVM是多线程的

        //创建垃圾
        for (int i = 0; i < 1000000; i++){
            new Test();
        }
        //主线程
        for (int i = 0; i < 10000; i++){
            System.out.println("我是主线程");
        }
    }
}
class Test {
   @Override
    public void finalize(){
       System.out.println("垃圾被回收了");
   }
}
NO.2 多线程实现方式(一)
  MyThread mt = new MyThread();//创建线程的子类对象
         // mt.run();
         mt.start();//开启线程
         //为了看效果，我们在主线程中也写点东西
        for (int i = 0; i < 10000; i++){
            System.out.println("kobekobekobe");
        }
        //执行后，如果是开辟了新的线程，那么这两个打印应该时交替打印的
        //结果却没有，是因为我们的方法没调用好。应该是用start方法开启线程
     }
}
class MyThread extends Thread {//1.继承Thread
  //2.重写run方法
    public  void run(){
        //3.将自己想执行的代码放这里面
        for (int i = 0; i < 10000; i++){
            System.out.println("tmactmactmac");
        }
    }
}
NO.3 多线程实现方式(二)
 MyThread mt = new MyThread();
        //Runnable接口中只有一个run方法，没有启动线程的方法，需要借助于Thread类
        Thread tr = new Thread(mt); //用Thread的构造方法将实现了Runnable接口的类作为参数
        tr.start();
 //主线程方法
        for (int i = 0; i < 10100; i++){
            System.out.println("bbbbbbbbbbbbbbbbbb");
        }
    }
}
class MyThread implements Runnable {//1.实现Runnable接口
    //2.重写run方法
    public void run(){
        for (int i = 0; i < 10000; i++){
            System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaa");
        }
    }
}
NO.4 匿名内部类实现线程的两种方式
//匿名内部类实现多线程方式一:继承Thread
        new Thread() { //1.继承Thread类
            public void run() {//2.重写run方法
                for (int i = 0; i < 10000; i++) {
                    System.out.println("aaaaaaaaaaa");
                }
            }
        }.start();//调用start方法开启线程

        //主线程方法
        for (int i = 0; i < 100000; i++){
            System.out.println("bbbbbb");
        }

 // //匿名内部类实现多线程方式二:Runnable实现
        //写好后将整个new Runnable作为一个参数传给Thread
        new Thread(new Runnable() {
            public void run(){
                for (int i = 0; i < 100000; i++) {
                    System.out.println("cccccccccccccccccccc");
                }
            }
        }).start();
NO.5 多线程获取名字和设置名字
 //多线程取名和设置名称
        //创建一条线程
        //通过构造方法给线程命名
        new Thread("JJ的线程") {
            public void run() {
                //this.getName():获取线程名
                System.out.println( this.getName() +  " -aaaaaaaaaaa");
            }
        }.start();
        //创建另一条线程
        new Thread("麦迪的线程") {
            public void run() {
                System.out.println( this.getName() +  " -bbbbbb");
            }
        }.start();
        //打印结果:Thread-0 -aaaaaaaaaaa
        //Thread-1 -bbbbbb

        //setName给线程取名
        MyThread mr = new MyThread();
        mr.setName("科比的线程");
        mr.start();
    }
}
class MyThread extends Thread {//1.实现Runnable接口
    //2.重写run方法
    public void run(){
        System.out.println(this.getName() + "-ccccccc");
    }
}
NO.6 获取当前线程对象
 //获取当前线程
        //通过构造方法给线程命名
        new Thread("JJ的线程") {
            public void run() {
                System.out.println( this.getName() +  " -aaaaaaaaaaa");
            }
        }.start();
        //创建另一条线程

        Thread tr = new Thread( new Runnable() {
            public void run(){
                //Thread.currentThread()就是获得当前线程
                System.out.println(Thread.currentThread().getName() +  "-bbbb");
            }
        });
        tr.setName("麦迪的线程");
        tr.start();

        //当然也可以设置主线程名字
        Thread.currentThread().setName("我是主线程");
        //再打印一下主线程的线程--在主方法中调用的就是主线程
        System.out.println(Thread.currentThread().getName());
NO.7 休眠线程
//休眠线程
//        for (int i = 20; i >= 0; i--){
//            //调用休眠方法--这里要抛出一个中断异常
//            Thread.sleep(1000);//这里面传入的是毫秒值
//            System.out.println("倒计时" + i + "秒");
//        }

        //在自己的线程中用sleep
        new Thread(){
            public void run(){
                for (int i = 20; i >= 0; i--){
                    //调用休眠方法--这里要抛出一个中断异常
                    try {
                        this.sleep(1000);//这里面传入的是毫秒值
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("倒计时" + i + "秒");
                }
            }
        }.start();
NO.8 守护线程
 //守护线程:这样理解守护线程相当于象棋中的其他棋子，然后非守护线程就相当于将
        //当将死亡(执行完)，那么守护线程也就得直接挂掉了
        Thread t1 = new Thread() {
            public void  run(){
                for (int i = 0; i < 2; i++){
                    System.out.println(this.getName() + "----111111");
                }
            }
        };
        t1.setName("t1的线程");
        Thread t2 = new Thread() {
            public void  run(){
                for (int i = 0; i < 10; i++){
                    System.out.println(this.getName() + "----22");
                }
            }
        };
        t2.setName("t2的线程");

        //按照上面的理解，我们将t2设置为守护线程，这样当t1执行完后，t2也就随之挂掉了
        t2.setDaemon(true);
        t1.start();
        t2.start();
NO.9 加入线程
 //加入线程--相当于插队，插入的线程要先执行完了，被插入线程才能执行

       final Thread t1 = new Thread() {
            public void  run(){
                for (int i = 0; i < 10; i++){
                    System.out.println(this.getName() + "----111111");
                }
            }
        };
        t1.setName("t1的线程");


        Thread t2 = new Thread() {
            public void  run(){
                for (int i = 0; i < 10; i++){
                    if (i == 3){
                        try {
                            t1.join();//将t1线程插t2线程的执行中
                            //t1.join(10000);还可以指定插入线程的执行时间，过了这个时间，线程间还是交替执行
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    System.out.println(this.getName() + "----22");
                }
            }
        };
        t2.setName("t2的线程");
        t1.start();
        t2.start();
NO.10 礼让线程
 //礼让线程--只作了解
        Thread t1 = new Thread() {
            public void run(){

                for (int i = 0; i < 500; i++){
                    System.out.println(this.getName() + "线程在执行");
                }
            }
        };

        MyThread mt = new MyThread();
        mt.start();
        t1.start();
    }
}
class MyThread extends Thread {//1.实现Runnable接口
    //2.重写run方法
    public void run(){
       for (int i = 1; i <= 1000; i++){
            if (i % 10 == 0 ){

           Thread.yield();//只要是10的倍数,这个线程就让出cpu
                System.out.println(this.getName() + "线程在让出cpu");
            }else{
                System.out.println(this.getName() + "-ccccccc");
            }

       }

    }
}
NO.11 设置线程优先级
//线程优先级
        Thread t1 = new Thread() {
            public void run(){

                for (int i = 0; i < 10; i++){
                    System.out.println(this.getName() + "线程在执行");
                }
            }
        };

        Thread t2 = new Thread() {
            public void run(){

                for (int i = 0; i < 10; i++){
                    System.out.println(this.getName() + "线程在执行");
                }
            }
        };

        t1.setPriority(1);//线程优先级范围1-10之间//10最高
        t2.setPriority(10);//设置优先级，不是说要一个线程执行完了，另一个线程才能执行。
        //只是一个线程获得cpu的执行次数要多些而已
        t2.start();
        t1.start();
NO.12 线程同步代码块
//线程同步代码块:当一个线程中要执行多段代码，我们希望这个线程中正在执行的多段代码
        //不要受到线程切换的影响，就需要给加一个同步代码块，这样保证一个线程中的一次执行能够完整的完成
       final  Printer p1 = new Printer();
       //为什么这个Printer前面要有个final修饰符
        //因为p1在匿名内部类中使用了，作为匿名内部类的局部变量，必须用final修饰
         //创建线程
        new Thread() {
            public void run(){
                int i = 100000000;
                while (i>0){//不断调用p1中的方法
                    p1.print();
                    i--;
                }
            }
        }.start();

        new Thread() {
            public void run(){
                int i = 10;
                while (i>0) {//不断调用p1中的方法
                    p1.print2();
                    i--;
                }
            }
        }.start();
    }
}
//打印机类
class Printer {
    Test test = new Test();//所对象可以是任意的，且两个锁的对象得是一样的
    public  void print(){
        synchronized (test){//同步代码块，锁对象:其中要传入的所对象，可以是任意的，但是不能是匿名对象
            System.out.print("C");
            System.out.print("罗");
            System.out.print("威");
            System.out.println("武");
        }

    }
    public  void print2(){
        synchronized (test){
            System.out.println("我是小菜鸟");
        }
    }
}
class Test {}
NO.13 多线程的同步方法
/**
     * @param args
     * 同步代码块
     */
    public static void main(String[] args) {
        final Printer2 p = new Printer2();
        
        new Thread() {
            public void run() {
                while(true) {
                    p.print1();
                }
            }
        }.start();
        
        new Thread() {
            public void run() {
                while(true) {
                    p.print2();
                }
            }
        }.start();
    }

}

class Printer2 {
    Demo d = new Demo();
    //非静态的同步方法的锁对象是神马?
    //答:非静态的同步方法的锁对象是this
    //静态的同步方法的锁对象是什么?
    //是该类的字节码对象
    public static synchronized void print1() {                          //同步方法只需要在方法上加synchronized关键字即可
        System.out.print("黑");
        System.out.print("马");
        System.out.print("程");
        System.out.print("序");
        System.out.print("员");
        System.out.print("\r\n");
    }
    
    public static void print2() {
        //synchronized(new Demo()) {                            //锁对象不能用匿名对象,因为匿名对象不是同一个对象
        synchronized(Printer2.class) {      
            System.out.print("传");
            System.out.print("智");
            System.out.print("播");
            System.out.print("客");
            System.out.print("\r\n");
        }
    }
}
NO.14 线程安全问题--卖票例子
 //练习铁路窗口:一共100张票，通过4个窗口卖完
        //多线程并发操作同一数据时，就有可能出现线程安全问题
        //使用同步技术可以解决这种问题，把操作数据的代码进行同步，不要多个线程一起操作
        //开启四条线程购票
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
        //我们这样操作，就成了每一个窗口都有100张票，各卖各的了
        //我们的初衷是四个窗口共同一起卖100张票
        //我们可以将这100张票弄成类变量，就成了四个对象公有的了
    }
}

class  Ticket extends Thread {

    private static int ticket = 100;//这是100张火车票
     public  void run(){
        synchronized (Ticket.class) {//加锁
            while (true) {

                if (ticket ==  0) {//票卖完了,我们就跳出这个循环
                    System.out.println("票卖完了");
                    break;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(this.getName() + "--这是第" + ticket-- + "号票");

            }
        }

     }
}
NO.15 上面例子用Runnable实现
/**
     * @param args
     * 火车站卖票的例子用实现Runnable接口
     */
    public static void main(String[] args) {
        MyTicket mt = new MyTicket();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        new Thread(mt).start();
        
        /*Thread t1 = new Thread(mt);               //多次启动一个线程是非法的
        t1.start();
        t1.start();
        t1.start();
        t1.start();*/
    }

}

class MyTicket implements Runnable {
    private int tickets = 100;
    @Override
    public void run() {
        while(true) {
            synchronized(this) {
                if(tickets <= 0) {
                    break;
                }
                try {
                    Thread.sleep(10);               //线程1睡,线程2睡,线程3睡,线程4睡
                } catch (InterruptedException e) {
                    
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "...这是第" + tickets-- + "号票");
            }
        }
    }
}
NO.16 多线程死锁
/**
     * @param args
     */
    private static String s1 = "筷子左";
    private static String s2 = "筷子右";

    public static void main(String[] args) {
        new Thread() {
            public void run() {
                while(true) {
                    synchronized(s1) {
                        System.out.println(getName() + "...获取" + s1 + "等待" + s2);
                        synchronized(s2) {
                            System.out.println(getName() + "...拿到" + s2 + "开吃");
                        }
                    }
                }
            }
        }.start();
        
        new Thread() {
            public void run() {
                while(true) {
                    synchronized(s2) {
                        System.out.println(getName() + "...获取" + s2 + "等待" + s1);
                        synchronized(s1) {
                            System.out.println(getName() + "...拿到" + s1 + "开吃");
                        }
                    }
                }
            }
        }.start();
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 220,976评论 6赞 513
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 94,249评论 3赞 396
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 167,449评论 0赞 360
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 59,433评论 1赞 296
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 68,460评论 6赞 397
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 52,132评论 1赞 308
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,721评论 3赞 420
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 39,641评论 0赞 276
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 46,180评论 1赞 319
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 38,267评论 3赞 339
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 40,408评论 1赞 352
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 36,076评论 5赞 347
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,767评论 3赞 332
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 32,255评论 0赞 23
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 33,386评论 1赞 271
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 48,764评论 3赞 375
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 45,413评论 2赞 358

推荐阅读更多精彩内容

  • Java多线程（一）基础知识
    线程概述 线程与进程 进程  每个运行中的任务（通常是程序）就是一个进程。当一个程序进入内存运行时，即变成了一个进...
    闽越布衣阅读 1,010评论 1赞 7
  • Java多线程（一）多线程基础
    前言 本文主要讲解java多线程的基础，以及一些常用方法。关于线程同步、ExecutorService框架我会放到...
    crossoverJie阅读 1,468评论 2赞 22
  • Java 多线程（一）
    一、基本概念：程序 - 进程 - 线程 程序(program)：是为完成特定任务、用某种语言编写的一组指令的集合。...
    c5fc16271aee阅读 471评论 0赞 2
  • Java多线程(一)
    Java多线程(Multiple Threads) (一) 本文是作者的原创文章，未经同意禁止转载 @Eric_L...
    eric_lai阅读 344评论 0赞 1
  • 钱是一个人最大的底气20171127
    很多机会都来自于被欣赏。沉着自如，优雅得体的形象，有时能为你打开一扇走向更高处的大门，可以让你实现个人价值最大化，...
    爱你的Lisa阅读 414评论 0赞 0