多线程——多线程基础

多线程概念

并行和并发

1.并行：多个指令多核CPU上同时执行
2.并发：同一个CPU核心，交替执行多条指令

进程和线程

1.进程：正在执行的程序
2.线程：线程是进程中的一个执行单元(路径)，如果一个进程中包含多个线程，这个程序就是多线程程序。
		QQ、迅雷、360、飞秋等

创建线程的方式

线程的实现方式1

Java的API提供了一个Thread类表示线程，创建一个Thread及其子类对象，即是线程对象。

1.写一个Thread的子类
2.复写run方法
3.创建子类对象
4.调用start()方法，开启线程

//1.写一个Thread的子类
public class DownloadThread extends Thread{
    //2.复写run方法. run方法中的代码就是线程的执行代码
    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {
            //获取线程的名称
            String name = getName();
            System.out.println(name+"....正在下载..."+i+"%");
        }
    }
}

public class Demo1 {
    public static void main(String[] args) {
        //创建线程对象
        DownloadThread dt=new DownloadThread();
        //开启线程
        dt.start();

        //创建线程对象
        DownloadThread dt1=new DownloadThread();
        //开启线程
        dt1.start();
    }
}

线程的实现方式2

1.写一个Runnable接口的子类
2.复写run方法
3.创建Thread对象，把Runnable接口的子类对象作为参数传递
4.调用start()方法，开启线程

//线程的执行任务
public class DownloadRunnable implements Runnable{
    //run方法中的代码就是线程的执行代码
    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {
            //获取当前正在执行的线程
            Thread thread = Thread.currentThread();
            //再通过线程来获取名称
            String name = thread.getName();
            System.out.println(name+"....正在下载..."+i+"%");
        }
    }
}

public class Demo2 {
    public static void main(String[] args) {
        //线程任务的对象
        DownloadRunnable dr = new DownloadRunnable();

        //创建线程对象，指定任务
        Thread t1 = new Thread(dr);
        t1.start();

        //创建线程对象，指定任务
        Thread t2 = new Thread(dr);
        t2.start();
    }
}

线程的实现方式3

1.写一个Callable接口的子类
2.复写call方法。有返回值
3.创建Callable的子类对象
4.创建FutureTask对象，把Callable的子类对象作为参数传递
5.创建Thread对象，把FuTureTask对象作为参数传递
6.调用start方法，开启线程

注意：如果想的到线程的执行结果，在start方法调用之后，调用FuTureTask对象的get方法

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        //求1~100的和
        int sum=0;
        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

public class Demo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3.创建Callable的子类对象
        MyCallable mc=new MyCallable();
        //4.创建FutureTask对象，把Callable的子类对象作为参数传递
        FutureTask<Integer> ft=new FutureTask<>(mc);

        //5.创建Thread对象，把FuTureTask对象作为参数传递
        Thread t=new Thread(ft);
        //6.调用start方法，开启线程
        t.start();

        //注意：如果想的到线程的执行结果，在start方法调用之后，调用FuTureTask对象的get方法
        Integer result = ft.get();
        System.out.println(result);
    }
}

三种实现方式的对比

1.继承Thread方式：继承Thread类之后不能再继承其他类
2.实现Runnable接口：扩展性较强，可以继承其他类，同时还可以实现多个接口
3.实现Callable接口：线程执行完之后有返回结果

Thread类的方法

public void setName(String name)
    设置线程的名称
public String getName()
    获取线程的名称
    
public static Thread currentThread()
    获取当前正在执行的线程对象
public static void sleep(long time)
    让线程休眠指定的毫秒值。

public void setPriority(int newPriority) 
     更改线程的优先级。优先级越高，执行到的几率越大
     范围：[1,10]
public int getPriority() 
     获取线程的优先级。 
public void setDaemon(boolean flag)
     设置线程为守护线程
     当主线程停止运行，守护线程也会跟着停止运行。

线程安全问题

多个线程在访问共享数据时，由于CPU的随机性，一个线程还没有执行完，执行权被其他线程抢走了，这个时候就有可能出现线程安全问题。

同步代码块

//锁对象：可以是任意对象，但是要保证唯一
synchronized(锁对象){
    //多个线程访问共享数据的代码
}

以下案例模拟多个线程共卖100张票，为了保证线程安全加上了同步代码块。

public class TicketRunnable implements Runnable {
    int ticket = 100;
    //Object obj=new Object(); 
    @Override
    public void run() {
        while (true) {
            //锁对象：可以是任意对象,要保证是唯一的
            synchronized (TicketRunnable.class) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //获取线程名称
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "...正在卖第" + ticket + "号票");
                    ticket--;
                } else {
                    break; 
                }
            }
        }
    }
}

public class Demo4 {
    public static void main(String[] args) {
        TicketRunnable tr=new TicketRunnable();
        //创建两个线程，并执行
        new Thread(tr,"窗口A").start();
        new Thread(tr,"窗口B").start();
    }
}

同步方法

//同步方法：一个线程执行这个方法，另一个线程就必须等待
//同步方法的锁对象：this
public synchronized void method() {
    if (ticket > 0) {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //获取线程名称
        String name = Thread.currentThread().getName();
        System.out.println(name + "...正在卖第" + ticket + "号票");
        ticket--;
    }
}

Lock锁

ReentrantLock  lock = new ReentrantLock(); 
//上锁
lock.lock();  //一个线程执行到这里，其他线程就必须在这里等

//有可能产生安全问题的代码

//解锁
lock.unlock(); //等这个线程执行完了，其他线程才能进来执行。

改造上面的同步代码块

public class TicketRunnable implements Runnable {
    int ticket = 100;
    //创建锁对象
    ReentrantLock  lock = new ReentrantLock(); 
    @Override
    public void run() {
        while (true) {
            lock.lock(); //上锁
            try {
                //锁对象：可以是任意对象,是唯一的
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //获取线程名称
                    String name = Thread.currentThread().getName();
                    System.out.println(name + "...正在卖第" + ticket + "号票");
                    ticket--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //不管前面有没有异常发生，锁都得关闭。
                lock.unlock();
            }
        }
    }
}