多线程学习之线程的创建、线程执行顺序、循环创建线程《一》

1. 线程创建

//1. 重写run()方法创建一个线程

Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开始执行线程");
                int a = 0;
                for (long i = 0; i < count; i++) {
                    a += 5;
                }
                System.out.println("a:" + a);
            }
        });
   thread1.start();

  //2. lambda表达式创建线程
  
  new Thread(() -> System.out.println("这最简单的lambda线程")).start();

// 3. lambda表达式创建线程并定义名字


        new Thread(() -> {
            while (i <= 100) {
                if (flag == false) {
                    System.out.println(Thread.currentThread().getName() + i);
                    i++;
                    flag = true;
                }else {
                    System.out.println("奇"+i);
                }
            }
        }, "奇数线程：").start();

// 4. lambda创建自定义线程

Runnable runner4 = ()->{

            StringBuffer s = new StringBuffer();
            System.out.println("这是自定义的lambda线程");
            for(int i= 0;i < 10;i++) {
                System.out.println(s.append("haha"));
            }

        };

        new Thread(runner4).start();

// 5. 实现runable接口 创建线程
public class MyRunable implements Runnable {
    @Override
    public void run() {
        System.out.println("000");
    }

    public static void main(String[] args) {
        new Thread(new MyRunable()).start();
    }
}

2. 线程执行顺序

 //2. 让线程thread2在线程thread1之后执行
 
 Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    thread1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("开始执行线程222");
                int a = 0;
                for (long i = 0; i < count; i++) {
                    a += 5;
                }
                System.out.println("a222:" + a);
            }
        });

/*
        让三个线程安装顺序执行，如t1,t2,t3 想 t1执行，t2然后执行，t3最后执行
        只需要在线程创建的时候，t2里面写 t1.join();
        t3里面写t2.join();
        而不在乎他们的启动start的书写顺序
     */

3. 线程重命名

线程重命名： 
1. public Thread (Runnable Target,String name) 
2.  thread.setName()
3. lambda重命名
1new Thread(() -> {
            dosomething()....
        }, "线程名字").start();

4. 线程状态

1. 建之后，调用start()方法开始运行。当线程执行wait()方法之后，线程进入等待状态。
2. 待状态的线程需要依靠其他线程的通知才能够返回到运行状态，
3. 等待状态相当于在等待状态的基础上增加了超时限制，也就是超时时间到达时将会返回到运行状态。
4. 用同步方法时，在没有获取到锁的情况下，线程将会进入到阻塞状态。
5. 执行Runnable的run()方法之后将会进入到终止状态。

阻塞状态：
是线程阻塞在进入synchronized关键字修饰的方法或代码块（获取锁）时的状态，但是阻塞在
java.concurrent包中Lock接口的线程状态却是等待状态，因为java.concurrent包中Lock接口对于
阻塞的实现均使用了LockSupport类中的相关方法。

---

5. for出来十个顺序线程

//for 循环创建多个普通的无序线程

for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread();
            thread.setName("线程"+i);
            thread.start();
        }

// for循环出来十个顺序线程

import java.util.concurrent.TimeUnit;

public class Join {
    public static void main(String[] args) throws Exception {
        Thread previous = Thread.currentThread();
        for (int i = 0; i < 10; i++) {
            // 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
            Thread thread = new Thread(new Domino(previous), String.valueOf(i));
            thread.start();
            previous = thread;
        }
        TimeUnit.SECONDS.sleep(5);
        System.out.println(Thread.currentThread().getName() 
        + " terminate." + "........");
    }

    static class Domino implements Runnable {
        private Thread thread;

        public Domino(Thread thread) {
            this.thread = thread;
        }

        public void run() {
            try {
                thread.join();
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread().getName() + " terminate.");
        }
    }
}

6. 什么是守护线程？

Java的线程分为两种：User Thread(用户线程)、DaemonThread(守护线程)。
只要当前JVM实例中尚存任何一个非守护线程没有结束，守护线程就全部工作；
只有当最后一个非守护线程结束是，守护线程随着JVM一同结束工作，
Daemon作用是为其他线程提供便利服务，守护线程最典型的应用就是GC(垃圾回收器)，
他就是一个很称职的守护者。
User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：
如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。
因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

 

---