Java之多线程

1，多线程的作用:

　　线程是程序执行的一条路径, 一个进程中可以包含多条线程，多线程并发执行可以提高程序的效率, 可以同时完成多项工作

1.1，多线程的应用场景:

红蜘蛛同时共享屏幕给多个电脑
迅雷开启多条线程一起下载
QQ同时和多个人一起视频
服务器同时处理多个客户端请求
读取超大文件时

1.2，线程并发与并行的区别：

区别:
　　并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
　　并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
简单释义:
　　如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
　　比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。

1.3，线程的生命周期:

新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();
就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；
运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；
阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态。根据阻塞产生的原因不同，阻塞状态又可以分为三种
- 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；
- 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；
- 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

2，线程的三种创建方式：

2.1，继承Thread类：

public class Demo01_Thread {
    public static void main(String[] args) {
        MyThread mh = new MyThread();    //4.创建Thread类的子类对象
        mh.start();                        //5.开启线程
    }
}
class MyThread extends Thread{                //1.继承Thread
    @Override
    public void run() {                        //2.重写run方法
        for (int i = 0; i < 10000; i++) {    //3.将要执行的代码写在run方法中
            System.out.println(getName+"继承线程已执行"+i);
        }
    }
}

如上代码所示，创建MyThread实例进入新建状态，然后调用start（）方法启动，但是线程不一定会立马启动，因为要看cpu的资源分配

2.2，实现Runnable:

public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();    //4.创建Runnable中的子类实例
        Thread tr = new Thread(mr);    //将Runnable中的子类变量放入Thread类中
        tr.start();
    }
}
class MyRunnable implements Runnable{    //1.定义类实现Runnable

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {    //2.重写Run方法
            System.out.println(Thread.currentThread().getName()+"Runnable中的线程执行:"+i);    //3.将要执行代码写在run方法中
        }
    }
}

源码的区别:
- 继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
- 实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
总结的优点与弊端:
- 继承Thread：
  - 优点:可以直接使用Thread类中的方法,代码简单　
  - 弊端:如果已经有了父类,就不能用这种方法　
- 实现Runnable接口:
  - 优点:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
  - 弊端:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

2.3，实现Callable创建线程:

    // 创建线程池对象
    ExecutorService pool = Executors.newFixedThreadPool(2);

    // 可以执行Runnable对象或者Callable对象代表的线程
    Future<Integer> f1 = pool.submit(new MyCallable(100));
    Future<Integer> f2 = pool.submit(new MyCallable(200));

    // V get()
    Integer i1 = f1.get();
    Integer i2 = f2.get();

    System.out.println(i1);
    System.out.println(i2);

    // 结束
    pool.shutdown();

    public class MyCallable implements Callable<Integer> {

        private int number;

        public MyCallable(int number) {
            this.number = number;
        }

        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int x = 1; x <= number; x++) {
                sum += x;
            }
            return sum;
        }

    }

上面是线程的作用，以及五种状态的详细讲解还有线程的创建方式，下面是对线程进行的一些操作。

3，多线程之同步代码块:

什么情况下需要同步？
- 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
- 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
同步代码块？
- 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
- 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

3.1，非静态方法使用锁让代码进行同步，锁对象可以是任意对象，只要相同就好:

class Printer {
    Demo d = new Demo();
    public static void print1() {
        synchronized(d){                //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
            System.out.print("大");     
            System.out.print("牛");
            System.out.print("is");
            System.out.print("me");
            System.out.print("哇");
            System.out.print("\r\n");
        }
    }

    public static void print2() {
        synchronized(d){
            System.out.print("噢");
            System.out.print("我");
            System.out.print("不");
            System.out.print("信");
            System.out.print("\r\n");
        }
    }
}

3.2，静态方法使用锁，让代码进行同步:

class Printer {
    public static void print1() {
        synchronized(Printer.class){                //锁对象可以是任意对象,但是被锁的代码需要保证是同一把锁,不能用匿名对象
            System.out.print("黑");
            System.out.print("马");
            System.out.print("程");
            System.out.print("序");
            System.out.print("员");
            System.out.print("\r\n");
        }
    }
    /*
     * 非静态同步函数的锁是:this
     * 静态的同步函数的锁是:字节码对象
     */
    public static synchronized void print2() {
        System.out.print("传");
        System.out.print("智");
        System.out.print("播");
        System.out.print("客");
        System.out.print("\r\n");
    }
}

3.3，多线程之多线程休眠(顾名思义就是休眠线程的):

　　Thread.sleep(毫秒,纳秒), 控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000

public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(getName()+"aaaaaaaaaaaa");
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(getName()+"bb");
                }
            }
        }.start();
    }
}

3.4，多线程之守护线程:

    //守护进程蛮特殊的,他会在别的线程执行完毕之后，然后再退出,java的gc用的就是守护进程
    Thread t1 = new Thread() {
        public void run() {
            for(int i = 0; i < 50; i++) {
                System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    Thread t2 = new Thread() {
        public void run() {
            for(int i = 0; i < 5; i++) {
                System.out.println(getName() + "...bb");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };
    t1.setDaemon(true);                        //将t1设置为守护线程
    t1.start();
    t2.start();

3.5，多线程之加入线程:

　　join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
　　join(int), 可以等待指定的毫秒之后继续

final Thread t1 = new Thread() {
public void run() {
    for(int i = 0; i < 50; i++) {
        System.out.println(getName() + "...aaaaaaaaaaaaaaaaaaaaaa");
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
};

Thread t2 = new Thread() {
    public void run() {
        for(int i = 0; i < 50; i++) {
            if(i == 2) {
                try {
                    //t1.join();                        //插队,加入
                    t1.join(30);                        //加入,有固定的时间,过了固定时间,继续交替执行
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(getName() + "...bb");
        }
    }
};
t1.start();
t2.start();

3.6，多线程之礼让线程（了解）:

public static void main(String[] args) {
        new MyTread().start();
        new MyTread().start();

    }
}
class MyTread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            if(i % 10 == 0){
                Thread.yield();//让出cpu
            }
            System.out.println(getName()+"..."+i);
        }
    }
}

3.7，多线程之设置线程的优先级（了解）:

public static void main(String[] args) {
    Thread t1 = new Thread(){
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(getName()+"aaaaaaaaaaaaa\t\t\t"+i);
            }
        };
    };

    Thread t2 = new Thread(){
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(getName()+"bb\t\t\t"+i);
            }
        };
    };
//        t1.setPriority(10);        //设置最大优先级
//        t2.setPriority(1);
    t2.setPriority(Thread.MIN_PRIORITY);    //最小
    t1.setPriority(Thread.MAX_PRIORITY);    //最大
    t1.start();
    t2.start();
    }
}

3.8，多线程之死锁：

　　多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁,尽量不要嵌套使用。

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();
}

3.9，多线程，两个线程间的通信:

1.什么时候需要通信
　　多个线程并发执行时, 在默认情况下CPU是随机切换线程的,如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
2.怎么通信
　　如果希望线程等待, 就调用wait(),如果希望唤醒等待的线程, 就调用notify(),这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用.

public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        mt.print1();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        mt.print2();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }
}
class MyThread{
    int flag =1;
    public void print1() throws InterruptedException{
        synchronized(this){
          if(flag !=1){                //当前线程等待
                this.wait();
          }
          System.out.print("第一个线程~");
          System.out.print("\r\n");
          flag = 2;
          this.notify();        //随机唤醒等待的线程
        }
    }
      public void print2() throws InterruptedException{

          synchronized(this){
          if(flag !=2){
            this.wait();
          }
          System.out.print("第二个线程~");
          System.out.print("\r\n");
          flag = 1;
          this.notify();
         }
     }
}

4,多线程,三个或三个以上间的线程通信:

多个线程通信的问题:
- notify()方法是随机唤醒一个线程
- notifyAll()方法是唤醒所有线程
- DK5之前无法唤醒指定的一个线程,如果多个线程之间通信, 需要使用notifyAll()通知所有线程, 用while来反复判断条件

public static void main(String[] args) {
        MyThread1 mt = new MyThread1();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        mt.print1();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        mt.print2();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        mt.print3();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }
}
class MyThread1{
    int flag =1;
    public void print1() throws InterruptedException{
        synchronized(this){
        while(flag !=1){                //当前线程等待
                this.wait();
          }
                  System.out.print("第一条线程~");
          System.out.print("\r\n");
          flag = 2;
//          this.notify();        //随机唤醒等待的线程
          this.notifyAll(); //唤醒全部~
        }
    }
      public void print2() throws InterruptedException{

          synchronized(this){
          while(flag !=2){
            this.wait();
          }
              System.out.print("第二条线程~");
          System.out.print("\r\n");
          flag = 3;
//          this.notify();
          this.notifyAll(); //唤醒全部~
         }
     }

      public void print3() throws InterruptedException{

          synchronized(this){
           while(flag !=3){    //线程3再次等待,if语句是在那里等待就在那里起来
            this.wait();
          }
          System.out.print("第三条线程~");
          System.out.print("\r\n");
          flag = 1;
//          this.notify();
          this.notifyAll(); //唤醒全部~
         }
     }
}

4.1，JDK1.5的新特性互斥锁：

同步
- 使用ReentrantLock类的lock()和unlock()方法进行同步
通信
- 使用ReentrantLock类的newCondition()方法可以获取Condition对象
- 需要等待的时候使用Condition的await()方法, 唤醒的时候用signal()方法
- 不同的线程使用不同的Condition, 这样就能区分唤醒的时候找哪个线程了

public static void main(String[] args) {
        MyThread2 mt = new MyThread2();
        new Thread(){
            public void run(){
                while(true){
                    try {
                        mt.print1();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
        }.start();
        new Thread(){
            public void run(){
                while(true){
                    try {
                        mt.print2();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
        }.start();

        new Thread(){
            public void run(){
                while(true){
                    try {
                        mt.print3();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
        }.start();
    }
}
class MyThread2{
    private ReentrantLock r = new ReentrantLock();
    private Condition c1 = r.newCondition();
    private Condition c2 = r.newCondition();
    private Condition c3 = r.newCondition();

    private int flag =1;
    public void print1() throws InterruptedException{
        r.lock();    //获取锁
        if(flag !=1){
                c1.await();    //await线程等待
          }
          System.out.print("第一条线程~");
          System.out.print("\r\n");
          flag = 2;
          c2.signal();    //线程唤醒
          r.unlock();//释放锁
    }
      public void print2() throws InterruptedException{
        r.lock();
          if(flag !=2){
            c2.await();
          }
          System.out.print("第二条线程~");
          System.out.print("\r\n");
          flag = 3;
          c3.signal();
          r.unlock();
     }

      public void print3() throws InterruptedException{
          r.lock();
          if(flag !=3){
            c3.await();
          }
          System.out.print("第三条线程~");
          System.out.print("\r\n");
          flag = 1;
          c1.signal();
          r.unlock();
     }
}

4.2，多线程，线程组的概述和使用(了解):

线程组概述
　　Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
　　默认情况下，所有的线程都属于主线程组。
方法:
　　public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
　　public final String getName()//通过线程组对象获取他组的名字

public static void main(String[] args) {
//      demo1();
        ThreadGroup tg = new ThreadGroup("我是一个新的线程组");    //创建新的线程组
        MyThread4 mt = new MyThread4();                        //创建Runnable的子类对象
        Thread m1 = new Thread(tg, mt,"张三");                //将线程m1放在族中
        Thread m2 = new Thread(tg, mt,"李四");                //将线程m1放在族中
        System.out.println(m1.getThreadGroup().getName());    //获取组名
        System.out.println(m2.getThreadGroup().getName());

    }

    private static void demo1() {
        MyThread4 mt = new MyThread4();

        Thread m1 = new Thread(mt,"张三");
        Thread m2 = new Thread(mt,"李四");
        ThreadGroup tg1 =m1.getThreadGroup();
        ThreadGroup tg2 =m2.getThreadGroup();
        System.out.println(tg1.getName());
        System.out.println(tg2.getName());
    }
}
class MyThread4 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+"..."+i);
        }
    }
}

4.3，多线程，线程池的概述和使用：

线程池概述:
- 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池
java内置线程池的使用概述
- JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
- public static ExecutorService newFixedThreadPool(int nThreads)
- public static ExecutorService newSingleThreadExecutor()

public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2); //创建一个线程池,可容纳俩线程
        pool.submit(new MyThread4());    //把线程放入线程池中
        pool.submit(new MyThread4());
        pool.shutdown();//关闭线程池
    }
}

字真多，溜啦溜啦，日常练习的希望能帮到大家

posted @ 2018-08-20 21:41 姜煜阅读(852) 评论(0) 编辑收藏举报

刷新页面返回顶部

屢敗屢戰