掌握JAVA多线程

多线程

多线程的创建方式

继承Thread

package day10;
/*创建线程的方式1步骤
1.创建一个类继承Thread
2.重写run()方法,这里实现代码逻辑
3.创建Thread子类的对象
4.执行start()方法
*/
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread m=new MyThread();
        m.start();
        for (int i=0;i<100;i++){
            if (i%2!=0){
                System.out.println(i+"*********************");
            }
        }
    }
}


//在创建过程中的一些补充
public class ThreadTest {
    public static void main(String[] args) {
        MyThread m=new MyThread();
        //问题一：start():启动线程；执行run()方法
        m.start();
//        m.run();
        //问题二:再启动一个线程时，则需再创建一个对象调用start()
        MyThread m1=new MyThread();
        m1.start();
        for (int i=0;i<100;i++){
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

线程的一些主要方法

start():启动当前线程，调用当前线程的run()
run()
currentThread():当前代码的线程
setName()
getName()
yield()：释放当前cpu的执行权
join()：在线程a中调用b.join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，结束阻塞状态。
sleep(long millitime):让当前线程”睡眠“指定毫秒，在指定的毫秒时，线程是阻塞状态
isAlive():判断当前线程是否存活

package day10;

class HelloThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
//            if (i%20==0){
//                yield();
//            }
        }
    }
}
public class ThreadTest3 {
    public static void main(String[] args) {
     HelloThread h=new HelloThread();
     h.start();

        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if (i==21){
                try {
                    h.join();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}




//sleep倒计时
package day10;
class MyThread4 extends Thread{
    @Override
    public void run() {
        System.out.println("倒计时开始");
        for (int i = 10; i>0; i--) {
            try {
                sleep(1000);

            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(i);

        }
        try {
            sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("新年快乐");
    }
}
public class ThreadTest4 {
    public static void main(String[] args) {
        MyThread4 m=new MyThread4();
        m.start();
    }
}

实现Runnable接口

package day10;

/**
 * 创建多线程的方式2
 * 1.实现runnable接口，实现run方法
 * 2.创建实现类的对象
 * 3.创建Thread的对象，将实现类的对象放入
 * 4.调用线程对象的start()方法
 */
class Runnable1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }

        }
    }
}
public class RunnableTest{
    public static void main(String[] args) {
        Runnable1 r=new Runnable1();
        Thread t=new Thread(r);
        t.start();

        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

实现Callable接口

package day12;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * 1.创建一个实现Callable的实现类
 * 2.重写call()方法
 * 3.创建实现类对象
 * 4.创建FutureTask的对象将实现类对象作为参数放入
 * 5.创建Thread类的对象，将futureTask作为参数放入
 * 6.调用start()启动线程
 */
class MyThread implements Callable{

    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            sum+=i;
        }
        return sum;
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        MyThread m=new MyThread();
        FutureTask futureTask=new FutureTask(m);
        new Thread(futureTask).start();
        try {
            //此方法是call()方法的返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }


}

线程池

package day12;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 通过线程池创建线程
 * 1.调用Executors的newFixedThreadPool()方法返回ExecutorService的对象
 * 2.调用ExecutorService对象的submit(Runnable run) 或 submit(Callable<V> call)
 * 3.调用shutdown()关闭线程池
 */
class Mythread1 implements Runnable{

    @Override
    public synchronized void run() {
        for (int i = 0; i < 100; i++) {

            if (i%2==0){
                try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
class MyThread2 implements Runnable{

    @Override
    public synchronized void run() {
        for (int i = 0; i < 100; i++) {

            if (i%2!=0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor threadPoolExecutor= (ThreadPoolExecutor) service;
        threadPoolExecutor.setCorePoolSize(15);
        service.submit(new Mythread1());
        service.submit(new MyThread2());

        System.out.println(service.getClass());
        service.shutdown();
    }
}

线程的生命周期

创建：调用start()

就绪: yield()

运行: run()

堵塞 sleep(long time),join(),wait(),suspend()

死亡:执行完run(),调用线程的stop(),出现异常也没处理

线程安全问题

方式一：同步代码块

方式二：同步方法

使用同步代码块解决实现Runnable接口的线程不安全问题

多个线程共用同一把锁

任何类的对象都可以充当锁

package day11;

/**
 * 同步代码块解决实现Runnable接口线程不安全问题
 * synchronized(同步监视器){
 *     需要被同步的代码
 * }
 * 同步监视器就是锁，任何一个类都可以充当锁
 */
class Window implements Runnable{

    private int ticket=100;
    Object obj=new Object();
    @Override
    public void run() {
        synchronized(obj) {
            while (true) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class SynchronizedTest {
    public static void main(String[] args) {
        Window w=new Window();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

使用同步代码块解决继承Thread类的线程不安全问题

package day11;

/**
 * 同步代码块解决继承Thread类的线程不安全问题
 * 同步监视器（锁）声明为静态，三个对象共用一个数据
 */
class Window1 extends Thread{
    private static int ticket=100;
    private static Object obj=new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                if (ticket>0){
                    System.out.println(getName()+":"+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }

    }
}

public class SynchronizedTest1 {
    public static void main(String[] args) {
        Window1 w1=new Window1();
        Window1 w2=new Window1();
        Window1 w3=new Window1();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

使用同步方法解决实现Runnable接口的线程不安全问题

package day11;

/**
 * 使用同步方法解决实现Runnable接口的线程不安全问题
 * 在方法中加一个synchronized关键字
 */
class Window2 implements Runnable{

    private int ticket=100;
    @Override
    public void run() {
        while (true){
            show();
        }
    }

    public synchronized void show(){
        if (ticket>0){
            System.out.println(Thread.currentThread().getName()+":"+ticket);
            ticket--;
        }
    }
}


public class SynchronizedTest2 {
    public static void main(String[] args) {
        Window2 w=new Window2();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

使用同步方法解决继承Thread类的线程不安全问题

package day11;

/**
 * 使用同步方法解决继承Thread类线程不安全问题
 * 同步方法为静态
 */
class Window3 extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
            show();
        }
    }

    public static synchronized void show(){
        if (ticket>0){
            System.out.println(Thread.currentThread().getName()+":"+ticket);
            ticket--;
        }
    }
}

public class SynchronizedTest3 {
    public static void main(String[] args) {
        Window3 w1=new Window3();
        Window3 w2=new Window3();
        Window3 w3=new Window3();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

使用同步机制将单例模式中的懒汉式改写为线程安全

package day11;

/**
 * 使用同步机制将单例模式中的懒汉式改写为线程安全的
 */
class Bank{
    private Bank(){}
    private static Bank bank=null;

    //方式一
//    private synchronized static Bank getInstance(){
//        if (bank==null){
//            bank=new Bank();
//        }
//        return bank;
//    }
    //方式二
    private  static Bank getInstance(){
        synchronized (Bank.class){
            if (bank==null){
                bank=new Bank();
            }
        }
        return bank;
    }
}

public class SingleTest {
}

解决线程不安全问题的方式三:Lock 锁

package day11;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程不安全问题的方式三
 */
class Window4 implements Runnable{

    private int ticket=100;

    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if (ticket>0){
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }
    }
}


public class SynchronizedTest4 {
    public static void main(String[] args) {
        Window4 w=new Window4();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

遍历1-100交替打印

wait():阻塞状态，并释放同步监视器

notify()：唤醒一个线程

notifyAll():唤醒所有线程

package day11;

class A implements Runnable{

    private int number=1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                notify();
                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                } else {
                    break;
                }
                try {
                    wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

public class CommunicationTest {
    public static void main(String[] args) {

        A a = new A();
        Thread t1=new Thread(a);
        Thread t2=new Thread(a);

        t1.setName("甲");
        t2.setName("乙");

        t1.start();
        t2.start();
    }
}

生产者消费问题

package day11;

class Clerk{
    private  int product=0;
    public Clerk(){
    }
    public synchronized void product(){
        if (product<20){

            product++;
            System.out.println(Thread.currentThread().getName()+"开始生产第"+product+"个产品");
            notify();
        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public synchronized void consume(){
        if (product>0){


            System.out.println(Thread.currentThread().getName()+"开始消费第"+product+"个产品");
            product--;
            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

}
class Producer implements Runnable{
    private Clerk clerk;

    public Producer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.product();
        }
    }
}

class Consume implements Runnable{

    private Clerk clerk;
    public Consume(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            clerk.consume();
        }
    }
}
public class CustomerTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer producer = new Producer(clerk);
        Thread t1=new Thread(producer);

        Consume consume = new Consume(clerk);
        Thread t2=new Thread(consume);

        t1.setName("生产者");
        t2.setName("消费者");

        t1.start();
        t2.start();
    }
}

区别比较

Callable接口比Runnable接口强大的原因

Callable的call()方法有返回值

call()方法抛出异常，可以被外部捕获异常信息

Callable支持泛型

开发中使用线程池比较广泛