Java多线程

一、认识多线程

              认识多线程之前要先认识进程。在程序运行时会，系统会给程序开辟一些内存和资源这就时进程。而进程中会有多个命令在同时执行，这就是多线程。

                Java多线程是指jvm虚拟机在同时执行多条命令。但实际上只是在多条命令件来回切换，用来增加处理器的利用率。比如：在吃饭时玩手机，从表面上来看我们在同时完成两件事，实际上我们只是在吃饭和玩手机之间来回切换，由于速度很快所以我们认为这两件事是同时完成的。

二、多线程的使用

        多线程的创建方法：

               (1)继承Theard

代码如下：

public class Thread1 extends Thread {//继承Thread类
    //重写run方法
    @Override
    public void run() {//重写run方法
        for (int i = 0; i < 10; i++) {
            System.out.println(java.lang.Thread.currentThread().getName()+"进程———>"+(i+1));
        }//进程实现的内容（输出1~10次）
    }
  public Thread1(String name){//重写构造方法，传递参数
        super(name);
  }
    public static void main(String[] args) {
        Thread1 t1=new Thread1("A");//创建两个进程对象
        Thread1 t2=new Thread1("B");
        t1.start();//开启进程（不能调用run方法，不然不能开启线程，只是普通的方法调用）
        t2.start();
    }
}

运行结果：

B进程———>1
B进程———>2
A进程———>1
B进程———>3
B进程———>4
B进程———>5
A进程———>2
B进程———>6
B进程———>7
B进程———>8
B进程———>9
B进程———>10
A进程———>3
A进程———>4
A进程———>5
A进程———>6
A进程———>7
A进程———>8
A进程———>9
A进程———>10

进程交替出现，说明两个进程的执行并不是按顺序的，而是同时执行的。每次运行的顺序也不相同。

(2)实现Runnable接口

public class Runnable1 implements Runnable{//实现接口Runnable，由于run方法内无内容，要重写才有实现接口
    @Override
    public void run() {//重写run方法
        for (int i = 0; i < 10; i++) {
            System.out.println(java.lang.Thread.currentThread().getName()
                                +"进程———>"+(i+1));
        }//进程实现的内容（输出1~10次）
    }
    public static void main(String[] args) {
        Runnable1 r1=new Runnable1();//创建实例对象
        Thread t1=new Thread(r1,"A");//创建示例对象线程
        Thread t2=new Thread(r1,"B");
        t1.start();//启动线程
        t2.start();
    }
}

运行结果：同上

(3)实现Callable<>接口（可带返回值）了解即可

三、常用方法

1）线程休眠：sleep(时间)

推迟线程：

public class TestSleep implements Runnable{
    @Override
    public void run() {//重写run方法
        for (int i = 0; i < 10; i++) {
            System.out.println(java.lang.Thread.currentThread().getName()+"进程———>"+(i+1));
        }//进程实现的内容（输出1~10次）
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable1 r1=new Runnable1();//创建实例对象
        Thread t1=new Thread(r1,"A");//创建示例对象线程
        Thread t2=new Thread(r1,"B");
        t1.start();//启动线程
        Thread.sleep(100);//此线程延迟100毫秒
        t2.start();
    }
}

计时器：

public class TestSleep1 implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i < 60; i++) {
            System.out.println("第"+i+"秒");
            try {
                Thread.sleep(1000);//每次延迟1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        TestSleep1 ts1=new TestSleep1();
        Thread t=new Thread(ts1);
        t.start();
    }
}

2）礼让：yield

public class TextThread  extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"第"+(i+1)+"次运行");
        }
    }
    public TextThread(String name){
        super(name);
    }
    public static void main(String[] args) {
        TextThread t1=new TextThread("线程1");
        TextThread t2=new TextThread("线程2");
        t1.start();
        Thread.yield();//礼让
        t2.start();
    }
}

1. 线程礼让，让当前正在执行的线程暂停,但不阻塞；
2. 将线程从运行状态转为就绪状态；
3. 让CPU重新调度,礼让不一定成功,看CPU心情。

3）插入join  

public class joinText implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
    public static void main(String[] args) {
        joinText jt=new joinText();
        Thread t1=new Thread(jt);
        Thread t2=new Thread(jt);
        t1.start();
        t2.start();
    }
}

运行结果：

Thread-1线程开始执行
Thread-0线程开始执行
Thread-1线程停止执行
Thread-0线程停止执行