Java 多线程、线程同步、线程池

一. 线程

1. 线程：线程(Thread)是一个程序内部的一条执行流程。

2. 程序中如果只有一条执行流程，那这个程序就是单线程的程序。

二. 多线程

多线程是指从硬件上实现多条执行流程的技术(多条线程由CPU负责调度)

Javas是通过java.lang.Thread类的对象来代表线程的

1. 多线程的创建方式一：继承Thread类

① 定义一个子类继承线程类(java.lang.Thread)，重写run()方法

② 创建子类线程对象

③ 调用线程对象的start()方法启动线程(启动后还是执行的run方法)

优点：编码简单；

缺点：线程继承了Thread类，无法继承其他类，不利于线程的扩展

注意事项：启动线程必须调用start()方法，不是调用run()方法；不要把主线程任务放在启动子线程之前


/*
* 1. 让子类继承Thread线程类
* */
public class MyThread extends Thread {

    //2.重写 run方法
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程类:" + i);
        }
    }
}




public class Test1_Thread {
    //main方法是由一条默认的主线程负责执行
    public static void main(String[] args) {
        //创建线程类对象
        Thread t = new MyThread();
        //启动线程
        t.start();//main线程的子线程

        //主线程任务在后
        //不要把主线程任务放在启动子线程之前(会导致执行完主线程任务后才会启动子线程)

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程：" + i);
        }
    }
}

2. 多线程的创建方式二：实现Runnable接口

① 定义一个线程任务类实现Runnable接口，重写run()方法；

② 创建任务类对象

③ 把任务类对象交给Thread处理(public Thread(Runnable target))

④ 调用线程对象的start()方法启动线程

优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强

缺点：需要多创建一个Runnable对象

/*
* implements Runnable 实现Runnable接口
* */
public class MyRunnable implements Runnable {

    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程：" + i);
        }
    }
}


public class Test2_Runnable {
    public static void main(String[] args) {
        //创建任务对象
        Runnable r = new MyRunnable();

        //把任务对象交给一个线程对象处理 public Thread(Runnable target)
        new Thread(r).start();


        //主线程
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程" + i);
        }
    }
}



public class Test3_Runnable {
    public static void main(String[] args) {
        //使用匿名内部类创建线程
        //1.直接创建Runnable接口的匿名内部类形式
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程" + i);
                }
            }
        };

        //启动线程
        new Thread(r).start();

        //简化1
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2" + i);
                }
            }
        }).start();

        //简化2
        new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                System.out.println("子线程3" + i);
            }
        }).start();

        //主线程
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程" + i);
        }
    }
}

3. 多线程的创建方式三：实现Callable接口

前面两种线程创建方式都存在一个问题：他们重写的run方法均不能直接返回结果；JDK5.0提供了Callable接口和FutureTask类来实现(多线程的第三种创建方式) ：可以直接返回线程执行的结果

(1) 创建任务对象：定义一个类实现Callable接口，重写call方法，封装要做的事情和要返回的数据。把Callable类型的对象封装成FutureTask(线程任务对象)。

(2) 把任务类对象交给Thread处理(public Thread(Runnable target))

(3) 调用线程对象的start()方法启动线程

(4) 线程执行完毕后、通过FutureTask对象的get方法去获取线程任务执行的结果。

FutureTask提供的构造器	说明
public FutureTask<>(Callable call)	把Callable对象封装成FutureTask对象

FutureTask提供的方法	说明
public V get() throws Exception	获取线程call方法返回的结果


public class MyCallable implements Callable<String> {
    private int num;
    public MyCallable(int num) {
        this.num = num;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < num; i++) {
            sum = sum + i;
        }
        return "sum:" + sum;
    }
}



public class Test4_Callable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //(1) 创建任务对象：定义一个类实现Callable接口，重写call方法，封装要做的事情和要返回的数据。
        Callable<String> callable = new MyCallable(10);
        //把Callable类型的对象封装成FutureTask(线程任务对象)。
        FutureTask<String> futureTask = new FutureTask<>(callable);
        // (2) 把任务类对象交给Thread处理(public Thread(Runnable target))
        //(3) 调用线程对象的start()方法启动线程
        new Thread(futureTask).start();
        //(4) 线程执行完毕后、通过FutureTask对象的get方法去获取线程任务执行的结果。
        // 假如上面的线程还没有执行完成，这里的代码会暂停，等待上面线程执行完毕后才会获取结果
        String s = futureTask.get();
        System.out.println(s);
    }
}

三. Thread的常用方法

Thread提供的常用方法	说明
public void run()	线程的任务方法
public void start()	启动线程
public String getName()	获取当前线程的名称，线程名称默认是Thread-索引
public void setName(String name)	设置线程名称
public static Thread currentThread()	获取当前执行的线程对象
public static void sleep(long time)	让当前执行的线程休眠多少毫秒后，再继续执行
public final void join() ...	让调用当前这个方法的线程先执行完

Thread提供的常见构造器	说明
public Thread(String name)	设置当前线程名称
public Thread(Runnable target)	封装Runnable对象为线程对象
public Thread(Runnable target, String name)	封装Runnable对象为线程对象，并指定线程名称

public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    public MyThread(){
        super();
    }

    //2.重写 run方法
    public void run() {
        Thread t = Thread.currentThread();
        for (int i = 0; i < 10; i++) {
            System.out.println(t.getName() + "线程:" + i);
        }
    }
}


public static void main(String[] args) throws Exception {
        //Thread的常用方法

        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        t1.start();
        t2.start();

        //主线程
        for (int i = 0; i < 10; i++) {
            //public static void sleep(long time)	让当前执行的线程休眠多少毫秒后，再继续执行
            if (i == 5 ){
                Thread.sleep(2000);
            }
            System.out.println("主线程" + i);
        }
        //public String getName()	获取当前线程的名称，线程名称默认是Thread-索引
        System.out.println(t1.getName());//Thread-0
        System.out.println(t2.getName());//Thread-1

        //public void setName(String name)	设置线程名称
        t1.setName("线程1");
        t2.setName("线程2");
        System.out.println(t1.getName());//线程1
        System.out.println(t2.getName());//线程2

        //public static Thread currentThread()	获取当前执行的线程对象
        // 哪个线程执行他，就会得到哪个线程对象
        Thread m = Thread.currentThread();
        System.out.println(m.getName());//main
        m.setName("主线程");
        System.out.println(m.getName());//主线程




        //public Thread(String name)	设置当前线程名称
        Thread t3 = new MyThread("线程3");
        System.out.println(t3.getName());//线程3

        //public final void join() ...	让调用当前这个方法的线程先执行完
        Thread t4 = new MyThread("线程4");
        t4.start();
        t4.join();

        Thread t5 = new MyThread("线程5");
        t5.start();
        t5.join();

        Thread t6 = new MyThread("线程6");
        t6.start();
        t6.join();
    }

四. 线程安全

线程安全问题：多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。

//账户类
public class Account {
    private double balance;
    private String accountId;

    public Account(double balance, String accountId) {
        this.balance = balance;
        this.accountId = accountId;
    }

    public Account() {
    }

    //取钱方法
    public void deposit(double amount) {
        String name = Thread.currentThread().getName();
        if (this.balance >= amount ) {
            System.out.println(
                    name + "取钱" + amount + " 成功"
            );
            balance = balance - amount;
            System.out.println(name + "余额" + this.balance);
        }else {
            System.out.println(name + "取钱" + amount + "余额不足");
        }
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String getAccountId() {
        return accountId;
    }

    public void setAccountId(String accountId) {
        this.accountId = accountId;
    }
}



//取钱线程
public class depositThread extends Thread{
    private Account account;
    public depositThread(Account account, String name) {
        super(name);
        this.account = account;
    }
    public void run() {
        account.deposit(100000);
    }
}





//main测试方法
public static void main(String[] args) {
        Account account = new Account(100000, "147852963" );
        new depositThread(account, "朵朵").start();
        new depositThread(account, "大宇").start();
    }

五. 线程同步

线程同步：解决线程安全问题的方案：让多个线程先后依次的访问共享资源；

常见方案：加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能在加锁进来。

1. 方式一：同步代码块

作用：把访问共享资源的核心代码给上锁，保证线程安全

格式：synchronized(同步锁){

访问公共资源的核心代码块

}

原理：每次只允许一个线程加锁进去，执行完毕后自动解锁，其他线程才可以进来执行

注意事项：对于当前执行的线程来说，同步锁必须是同一个对象，否则会出bug

锁对象的使用规范：

① 建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象

② 对于静态方法建议使用字节码(类名.class)对象作为锁对象

//取钱方法
    public void deposit(double amount) {
        String name = Thread.currentThread().getName();

        synchronized (this) {
            if (this.balance >= amount ) {
                System.out.println(
                        name + "取钱" + amount + " 成功"
                );
                balance = balance - amount;
                System.out.println(name + "余额" + this.balance);
            }else {
                System.out.println(name + "取钱" + amount + "余额不足");
            }
        }
    }

//如果为静态方法
    public static void deposit1(double amount) {
        String name = Thread.currentThread().getName();

        synchronized (Account.class) {
            
        }
    }





public static void main(String[] args) {
        Account account = new Account(100000, "147852963" );
        new depositThread(account, "朵朵").start();//
        new depositThread(account, "大宇").start();

        Account account1 = new Account(150000, "88888888" );
        new depositThread(account1, "欢欢").start();//
        new depositThread(account1, "麦琪").start();
}

2. 方式二：同步方法

作用：把访问共享资源的核心方法上锁，保证线程安全

格式：修饰符 synchronized 返回值类型方法名称(形参列表){

操作共享资源的代码

}

原理：每次只允许一个线程加锁进去，执行完毕后自动解锁，其他线程才可以进来执行

同步方法的底层原理：

① 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码

② 如果方法是实例方法：同步方法默认用this作为锁对象

③ 如果方法是静态方法：同步方法默认用类名.class作为锁对象

  public synchronized void deposit(double amount) {
        String name = Thread.currentThread().getName();

      
        if (this.balance >= amount ) {
            System.out.println(
                    name + "取钱" + amount + " 成功"
            );
            balance = balance - amount;
            System.out.println(name + "余额" + this.balance);
        }else {
            System.out.println(name + "取钱" + amount + "余额不足");
        }
        
    }



public static void main(String[] args) {
        Account account = new Account(100000, "147852963" );
        new depositThread(account, "朵朵").start();//
        new depositThread(account, "大宇").start();

        Account account1 = new Account(150000, "88888888" );
        new depositThread(account1, "欢欢").start();//
        new depositThread(account1, "麦琪").start();
    }

3. 方式三： Lock锁

Lock锁是jdk5开始提供的一个新的锁定方式，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。

Lock是接口，不能直接实例化，可以采用他的实现类ReentrantLock来构建Lock对象

构造器	说明
public ReentrantLock()	获得Lock锁的实现类对象

常用方法	说明
void lock()	获得锁
void unlock()	释放锁

public class Account {
    private double balance;
    private String accountId;
    //创建一个锁对象
    private final Lock lock = new ReentrantLock();

    public Account(double balance, String accountId) {
        this.balance = balance;
        this.accountId = accountId;
    }

    public Account() {
    }

    public void deposit(double amount) {
        String name = Thread.currentThread().getName();

        try {
            lock.lock();//加锁
            if (this.balance >= amount ) {
                System.out.println(
                        name + "取钱" + amount + " 成功"
                );
                balance = balance - amount;
                System.out.println(name + "余额" + this.balance);
            }else {
                System.out.println(name + "取钱" + amount + "余额不足");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();//解锁
        }

    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String getAccountId() {
        return accountId;
    }

    public void setAccountId(String accountId) {
        this.accountId = accountId;
    }
}



 public static void main(String[] args) {
        Account account = new Account(100000, "147852963" );
        new depositThread(account, "朵朵").start();//
        new depositThread(account, "大宇").start();

        Account account1 = new Account(150000, "88888888" );
        new depositThread(account1, "欢欢").start();//
        new depositThread(account1, "麦琪").start();
    }

六. 线程通信

1. 线程通信：当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源争夺

Object类的等待和唤醒方法	说明
void wait()	让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或notify()方法
void notify()	唤醒正在等待的单个线程
void notifyAll()	唤醒正在等待的所有线程

上述方法应当使用当前同步的锁对象进行调用。

七. 线程池

线程池：就是一个可以复用线程的技术。

不使用线程池的问题：用户每发起一个请求，后台就需要创建一个新的线程来处理，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，会影响系统的性能。

1. 创建线程池方式一实现类ThreadPoolExecutor

JDK5..0起提供了代表线程池的接口：ExecutorService，常用的实现类：ThreadPoolExecutor

ThreadPoolExecutor构造器

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

参数一：int corePoolSize：线程池的核心线程数量。

参数二：int maximumPoolSize：线程池的最大线程数量。

参数三：long keepAliveTime：临时线程的存活时间。

参数四：TimeUnit unit：临时线程存活的时间单位(秒，分，时，天)

参数五：BockingQueue<Runnable> workQueue：线程池的任务队列

参数六：ThreadFactory threadFactory：线程池的线程工厂

参数七：RejectedExecutionHandler handler：线程池的任务拒绝策略(线程都在忙，任务队列也满了的时候，新任务来了怎么处理)

拒绝策略	说明
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出RejectedExecutionException异常。默认
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但不抛出异常；不推荐
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务，然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线程负责调用任务的run()方法从而绕过线程池直接执行

临时线程的创建：新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

新任务拒绝：核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务

2. 使用线程池处理Runnable任务

ExecutorService的常用方法名称	说明
void execute(Runnable command)	执行Runnable任务
void shutdown()	等全部任务执行完毕后，再关闭线程池
List<Runnable> shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

public class MyRunnable implements Runnable {

    //重写run方法
    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName() + "--子线程打印：qwer" );

        try {
            //测试：将睡眠时间调至最大 观察临时线程
            Thread.sleep(Integer.MAX_VALUE);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}



public static void main(String[] args) {
        /*
        * public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
        * long keepAliveTime, TimeUnit unit, BockingQueue<Runnable> workQueue,
        *  ThreadFactory threadFactory, RejectedExecutionHandler handler)
        * */
        ExecutorService pool = new ThreadPoolExecutor(3,5,8, TimeUnit.MINUTES,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        //void execute(Runnable command)	执行Runnable任务
        Runnable r = new MyRunnable();
        pool.execute(r);//创建一个新线程
        pool.execute(r);//创建一个新线程
        pool.execute(r);//创建一个新线程

        pool.execute(r);//线程池的任务队列
        pool.execute(r);//线程池的任务队列
        pool.execute(r);//线程池的任务队列
        pool.execute(r);//线程池的任务队列

        pool.execute(r);//临时线程
        pool.execute(r);//临时线程

        //异常 RejectedExecutionException
        pool.execute(r);

        //void shutdown()	等全部任务执行完毕后，再关闭线程池
        pool.shutdown();

        //List<Runnable> shutdownNow()	立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务
        pool.shutdownNow();



}

3. 使用线程池处理Callable任务

Future<T> submit(Callable<T> task)

执行Callable任务，返回未来任务对象，用于获取线程返回的结果

public class MyCallable implements Callable<String> {
    private int num;
    public MyCallable(int num) {
        this.num = num;
    }
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i < num; i++) {
            sum = sum + i;
        }
        return Thread.currentThread().getName() + "--线程sum:" + sum;
    }
}



public static void main(String[] args) throws Exception {
        /*
        * public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
        * long keepAliveTime, TimeUnit unit, BockingQueue<Runnable> workQueue,
        *  ThreadFactory threadFactory, RejectedExecutionHandler handler)
        * */
        ExecutorService pool = new ThreadPoolExecutor(3,5,8, TimeUnit.MINUTES,
                new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());


        //Future<T> submit(Callable<T> task)	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
        Future<String> f1 = pool.submit(new MyCallable(10));
        Future<String> f2 = pool.submit(new MyCallable(20));
        Future<String> f3 = pool.submit(new MyCallable(30));
        Future<String> f4 = pool.submit(new MyCallable(40));
        Future<String> f5 = pool.submit(new MyCallable(50));
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());


    }

4. 创建线程池方式二Executors工具类实现线程池

Executors是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

常用方法	说明
public static ExecutorService newFixedThreadPool(int nThreads)	创建固定数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代
public static ExecutorService newSingleThreadExecutor()	创建只要一个线程的线程池对象，如果该线程出现异常而结束，那么线程会补充一个新线程
public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收
public static ExecutorService ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务

这些方法的底层，都是通过线程池的实现类对象ThreadPoolExecutor创建的线程池对象

public static void main(String[] args) {
        //public static ExecutorService newFixedThreadPool(int nThreads)	创建固定数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代
        ExecutorService pool = Executors.newFixedThreadPool(3);

        //public static ExecutorService newSingleThreadExecutor()	创建只要一个线程的线程池对象，如果该线程出现异常而结束，那么线程会补充一个新线程
        ExecutorService pool2 = Executors.newSingleThreadExecutor();

        //public static ExecutorService newCachedThreadPool()	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收
        ExecutorService pool3 = Executors.newCachedThreadPool();

        //public static ExecutorService ScheduledExecutorService newScheduledThreadPool(int corePoolSize)	创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务
        ExecutorService pool4 = Executors.newScheduledThreadPool(3);
}

计算密集型任务：核心线程数量=CPU的核数 + 1

IO密集型任务：核心线程数量=CPU的核数 + 2

5. Executors使用可能存在的陷阱

大型并发系统环境中使用Executors如果不注意可能会出现系统风险

八. 并发、并行、生命周期

1. 进程

进程：正在运行的程序(软件)就是一个独立的进程；线程是属于进程的，一个进程中可以同时运行多个线程；进程中的多个线程其实是并发和并行执行的

2. 并发

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮巡为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

3. 并行

在同一时刻上，同时有多个线程在被CPU调度执行

多线程是并发和并行同时进行的

4. 线程的生命周期

线程从生到死的过程中，经历的各种状态及状态转换

Java线程的状态：6中状态定义在了Thread类内部枚举类中

public enum State {
       
        //新建状态
        NEW,

        //可运行状态
        RUNNABLE,

        //锁 阻塞状态
        BLOCKED,

     
        //无限等待状态
        WAITING,

       //计时等待状态
        TIMED_WAITING,

        //被终止
        TERMINATED;
    }

线程状态	说明
NEW (新建)	线程刚被创建，但是并未启动
Runnable(可运行)	线程已经调用了start()，等待CPU调度
Blocked(锁阻塞)	线程在执行的时候未竞争到锁对象，该线程进入Blocked状态
Waiting(无限等待)	一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够用唤醒
Timed Waiting(计时等待)	同waiting状态，有几个方法(sleep，wait)有超时参数，调用他们则进入Timed Waiting(计时等待)状态
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止run方法而死亡

九. 悲观锁、乐观锁

1. 悲观锁：一上来就加锁，每次只能一个线程进入访问完毕后，在解锁。线程安全，性能较差

public class MyRunnable implements Runnable {
    private int num;
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //悲观锁
            synchronized (this) {
                System.out.println(Thread.currentThread().getName() + ":" + ++num);
            }
        }
    }
}


public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        //悲观锁
        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
}

2. 乐观锁：一开始不上锁，认为是没有问题的，等要出现线程安全问题的时候才开始控制。线程安全，性能较好。

public class MyRunnable2 implements Runnable {
   /* private int num;*/
    //整数修改的乐观锁 原子类实现
    private AtomicInteger num = new AtomicInteger();
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            //乐观锁
            System.out.println(Thread.currentThread().getName() + ":" + num.incrementAndGet());
        }
    }
}


 public static void main(String[] args) {
        Runnable runnable = new MyRunnable2();
        //乐观锁
        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
    }