JAVA基础——多线程

创建线程类

创建线程方式二

匿名内部类方法实现线程的创建

常用方法

常用方法

小结练习

一、 创建线程类

Java使⽤ java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其⼦类的实例。 Java中通过继承Thread类来创建并启动多线程的步骤如下：

1. 定义Thread类的⼦类，并重写该类的run()⽅法，该run()⽅法的⽅法体就代表了线程需要完成的任 务，因此把run()⽅法称为线程执⾏体。

2. 创建Thread⼦类的实例，即创建了线程对象

3. 调⽤线程对象的start()⽅法来启动该线程

   举例如下：

package Thread_a;
public class MyThread1 extends Thread{
    private String name;
    public MyThread1(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for(int i = 0; i <  10; i++){
            System.out.println(this.name+i);
        }
    }
}

package Thread_a;
public class Demo1 {
    public static void main(String[] args) {
        MyThread1 my1 = new MyThread1("1");
        MyThread1 my2 = new MyThread1("2");
        my1.start();
        my2.start();
        for(int i = 0; i < 10; i++){
            System.out.println("main"+i);
        }
    }
}

二、创建线程方式二

采⽤ java.lang.Runnable 也是⾮常常⻅的⼀种，我们只需要重写 run ⽅法即可。

步骤如下：

1. 定义Runnable接⼝的实现类，并重写该接⼝的run()⽅法，该run()⽅法的⽅法体同样是该线程的线程 执⾏体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是 真正的线程对象。
3. 调⽤线程对象的start()⽅法来启动线程。

package Thread_a;
public class MyThtaed2 implements Runnable {
    private String name;
    public MyThtaed2(String name){
        this.name = name;
    }
    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            System.out.println(this.name+i);
        }
    }
}

package Thread_a;
public class Demo2 {
    public static void main(String[] args) {
        MyThtaed2 my1 = new MyThtaed2("线程1:");
        MyThtaed2 my2 = new MyThtaed2("线程2:");
        Thread th1 = new Thread(my1);
        Thread th2 = new Thread(my2);
        th1.start();
        th2.start();
    }
}

三、匿名内部类方法实现线程的创建
使⽤线程的内匿名内部类⽅式，可以⽅便的实现每个线程执⾏不同的线程任务操作。 使⽤匿名内部类的⽅式实现 Runnable 接⼝，重写 Runnable 接⼝中的 run ⽅法：

        Thread t1 = new Thread(){
            public void run(){  
            }
        };
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
            }
        });
        Runnable r1 = new Runnable(){
            @Override
            public void run() {
            }
        };
        Thread t3 = new Thread(r1);

四、常用方法

public String getName() ：获取当前线程名称。

public void start() ：导致此线程开始执⾏；Java虚拟机调⽤此线程的run⽅法。

public void run() ：此线程要执⾏的任务在此处定义代码。

public static void sleep(long millis) ：使当前正在执⾏的线程以指定的毫秒数暂停（暂时 停⽌执⾏）。ps:类方法，需要Thread调用

public static Thread currentThread() ：返回对当前正在执⾏的线程对象的引⽤。

五、锁

1、synchronized

1.1、 synchronized 关键字可以⽤于⽅法中的某个区块中，表示只对这个区块的资源实⾏ 互斥访问。

ps：对象的同步锁只是⼀个概念，可以想象为在对象上标记了⼀个锁。

1. 锁对象，可以是任意类型。
2. 2. 多个线程对象，要使⽤同⼀把锁。

1.2、 使⽤ synchronized 修饰的⽅法，就叫做同步⽅法，保证A线程执⾏该⽅法的时候，其他 线程只能在⽅法外等着 。

格式：

synchronized(同步锁) {
 需要同步操作的代码
}

public synchronized void method() {
 可能会产⽣线程安全问题的代码
}

2、Lock

java.util.concurrent.locks.Lock 机制提供了⽐synchronized代码块和synchronized⽅法更⼴泛的 锁定操作，同步代码块/同步⽅法具有的功能Lock都有，除此之外更强⼤，更体现⾯向对象。

Lock锁也称同步锁，加锁与释放锁⽅法化了，如下：

public void lock() ：加同步锁。

public void unlock() ：释放同步锁。

Lock lock = new ReentrantLock();
lock.lock();
lock.unlock();

六、小结练习：

需求: 两个线程
线程1: 图片的加载 1% ~ 100%
线程2: 图片的显示 显示

package Thread_a;
public class Demo8 {
    public static void main(String[] args) {
        Thread load = new Thread(){
            public void run(){
                System.out.println("开始加载");
                for (int i = 1; i <= 100 ; i++) {
                    System.out.println("图片加载中"+i+"%");
                }
                System.out.println("加载完成");
            }
        };
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                System.out.println("等待加载>>>>");
                try {
                    load.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("显示图片");
            }
        };
        Thread show = new Thread(runnable);
        load.start();
        show.start();
    }
}