Java 多线程（1）

并发与并行

并发交替使用CPU执行多个任务，效率相对比较低；并行效率高，有多个CPU同时执行多个任务

进程与线程

程序存储在硬盘（永久存储ROM）中，如果需要执行该程序，首先要将程序移到内存（临时存储RAM）中，那么进入内存中的程序就叫做进程

线程调度

优先级别高的线程分得到的CPU资源就会更多，占用CPU的时间就相对越多

主线程

执行主（main）方法的线程

单线程程序：java程序中只有一个线程，执行从main方法开始，从上到下依次执行

单线程的缺陷

在出现异常之后 那么后面的代码就无法执行了

创建多线程

方法一创建Thread类的子类

创建MyThread类继承Thread类

package ThreadTest;

public class MyThread extends Thread {
    @Override
    public void run() {
        MyThreadMain.method();
//        method();
    }
    public void method(){
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread"+i);
        }
    }
}

 

package ThreadTest;

public class MyThreadMain {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main"+i);
        }
    }
    public static void method(){
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread"+i);
        }
    }
}

随机性打印结果原理

多进程内存图解

执行start方法的时候开辟了一块新的栈空间，而执行run方法的时候，在main方法给run方法开辟空间。

Thread类中的常用方法

获取线程名称 getName（）

设置线程名称

两种方法 setName以及用带参数的构造方法传递线程名称

package ThreadTest3;

public class MyThread extends Thread{

    public MyThread() {
    }

    public MyThread(String name) { // 当没有写带参方法时，默认送不带参的；但写了之后，就不送了，要自己写不带参的
        super(name);
    }
    @Override
    public void run() {
        // 打印当前线程名称
        System.out.println(Thread.currentThread().getName());
    }
}

package ThreadTest3;

public class ThreadMain {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.setName("线程1");
        mt.start();
        // 直接使用构造方法传线程名称
        new MyThread("使用带参构造函数创建线程").start();
    }
}

sleep方法

package ThreadTest3;

public class SleepTest {
    public static void main(String[] args) {
        for (int i = 0; i <= 60; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

创建线程方法二

 

Runnable接口的实现类

package ThreadTest3;

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

使用

package ThreadTest3;

public class RunnableMain {
    public static void main(String[] args) {
        RunnableImpl runnable = new RunnableImpl();
        Thread t = new Thread(runnable);
        t.start();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

使用实现Runnable接口的方式创建多线程的好处：

 

使用匿名内部类实现多线程创建 

由于只使用一次，所以也使用了匿名对象

package ThreadTest3;

public class InnerClassMain {
    public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+"->hang");
                }
            }
        }.start();

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + "->jing");
                }
            }
        };

        new Thread(runnable).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName()+"->zhang");
                }
            }
        }).start();

    }
}