Java多线程（四）

时间 2020-05-20 标签 java 多线程

Java多线程（一）：
https://blog.csdn.net/Veer_c/article/details/103842078
Java多线程（二）：
https://blog.csdn.net/Veer_c/article/details/103842263
Java多线程（三）：
https://blog.csdn.net/Veer_c/article/details/103842317
Java多线程（四）：
https://blog.csdn.net/Veer_c/article/details/103842602java

线程组

线程组：Java中使用ThreadGroup来表示线程组，它能够对一批线程进行分类管理，Java容许程序直接对线程组进行控制。默认状况下，全部的线程都属于主线程组。
public final ThreadGroup getThreadGroup():获取线程对应的线程组对象，咱们也能够给线程设置分组。
Thread(ThreadGroup group, Runnable target)
案例1：建立线程获取对应的线程组对象，并获取名称
案例2：建立线程组对象，给线程分配线程组web

public class MyRunnable implements Runnable{
    @Override
    public void run() {
    }
}
public class MyThread extends Thread{
    @Override
    public void run() {
    }
}
public class Test {
    public static void main(String[] args) {
        // 案例1：建立线程获取对应的线程组对象，并获取名称
        //建立两个线程
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        //获取上面两个线程对应的线程组对象
        ThreadGroup tg1 = mt1.getThreadGroup();
        ThreadGroup tg2 = mt2.getThreadGroup();
        //获取线程组对象的名称
        System.out.println(tg1.getName());//main--主线程祖，默认状况下，每个线程默认都属于主线程祖
        System.out.println(tg2.getName());
        System.out.println("-----------------");
        //案例2：建立线程组对象，给线程分配线程组
        //public ThreadGroup(String name)
        ThreadGroup tg = new ThreadGroup("刘德华");
        //public Thread(ThreadGroup group,Runnable target)
        Thread t3 = new Thread(tg, new MyRunnable());
        Thread t4 = new Thread(tg, new MyRunnable());
        //获取t3和t4的线程组对象
        ThreadGroup tg3 = t3.getThreadGroup();
        ThreadGroup tg4 = t4.getThreadGroup();
        System.out.println(tg3.getName());//刘德华
        System.out.println(tg4.getName());//刘德华
    }
}

线程池

使用线程池的缘由：
程序启动一个新线程成本是比较高的，由于它涉及到要与操做系统进行交互。而使用线程池能够很好的提升性能，尤为是当程序中要建立大量生存期很短的线程时，更应该考虑使用线程池。多线程

线程池的特色：
线程池里的每个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
在JDK5以前，咱们必须手动实现本身的线程池，从JDK5开始，Java内置支持线程池ide

线程池如何建立？
JDK5新增了一个Executors工厂类来产生线程池，有以下几个方法
public static ExecutorService newFixedThreadPool(int nThreads)svg

线程池的使用步骤：
1.建立线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);
2.建立Runnable实例
MyRunnable my = new MyRunnable();
3.提交Runnable实例
pool.submit(my);
pool.submit(my);
4.关闭线程池
pool.shutdown();性能

案例1：实现Runnable接口实现线程池的使用this

package com.edu_08;
public class MyRunnbale implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //线程池如何建立？
        //1.调用工厂类Executors
        //的public static ExecutorService newFixedThreadPool(int nThreads),返回一个线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //2.提交给线程池两个任务，都是打印0-99
        //建立任务
        MyRunnbale my1 = new MyRunnbale();
        MyRunnbale my2 = new MyRunnbale();
        //3.提交任务
        pool.submit(my1);
        pool.submit(my2);
        //关闭线程池
        //void shutdown()
        pool.shutdown();
    }
}

案例2：实现Callable接口实现线程池的使用spa

package com.edu_09;
import java.util.concurrent.Callable;
public class MyCallable implements Callable{
    //也是一个任务，只不过这个任务须要执行的方法是call(),这个方法有返回值
    @Override
    public Object call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i);
        }
        return null;
    }
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
    public static void main(String[] args) {
        //案例2：实现Callable接口实现线程池的使用
        //1.建立线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //建立一个任务
        MyCallable my1 = new MyCallable();
        MyCallable my2 = new MyCallable();
        //3.提交任务
        pool.submit(my1);
        pool.submit(my2);
        //4.关闭线程池
        pool.shutdown();
    }
}

案例3：实现Callable接口实现线程池的使用，实现多线程求和，1-10之和，1-100之和操作系统

package com.edu_10;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer>{//这里面的泛型就是call()方法返回值的类型
    private int start;
    private int end;
    public MyCallable(int start,int end){
        this.start = start;
        this.end = end;
    }
    @Override
    public Integer call() throws Exception {
        //在这里求取start--end之间的和
        int sum = 0;
        for (int i = start; i < end+1; i++) {
            sum+=i;
        }
        return sum;
    }
}
package com.edu_10;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Test {
    public static void main(String[] args) throws Exception{
        //1-10之和，1-100之和
        //1.建立线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //2.建立任务对象，建立任务对象的同时，将参数进行传递
        MyCallable my1 = new MyCallable(1,10);
        MyCallable my2 = new MyCallable(1, 100);
        MyCallable my3 = new MyCallable(1, 1000);
        //3.提交任务<T> Future<T> submit(Callable<T> task)
        Future<Integer> res = pool.submit(my1);
        Future<Integer> res2 = pool.submit(my2);
        Future<Integer> res3 = pool.submit(my3);
        //V get()若有必要，等待计算完成，而后获取其结果。 
        System.out.println(res.get());
        System.out.println(res2.get());
        System.out.println(res3.get());
        //4.关闭线程池
        pool.shutdown();
    }
}

定时器：Timer

public Timer()构造
public void schedule(TimerTask task, long delay) 延迟多久执行任务
public void schedule(TimerTask task,long delay,long period) 延迟多久执行任务，并之后每隔多久执行一次
public boolean cancel() 取消这个任务.net

TimerTask
public abstract void run()放的是所要执行的任务代码

案例1：上述方法使用：

package com.edu_11;
import java.util.Timer;
import java.util.TimerTask;
public class TimerTest {
    public static void main(String[] args) {
        //需求：在10秒钟后，在控制台打印一句话，helloworld
        //public Timer()构造
        Timer t = new Timer();
        //public void schedule(TimerTask task, long delay)延迟多久执行任务
        t.schedule(new MyTimerTask(t), 10000);
        //public void cancel()终止此计时器
        //t.cancel();//若是在这里关闭的话，咱们还没等任务执行完毕呢，计时器已经被关闭了
    }
}
//建立TimerTask的子类
class MyTimerTask extends TimerTask{
    private Timer t;
    public MyTimerTask(Timer t){
        this.t = t;
    }
    @Override
    public void run() {
        //此计时器任务要执行的操做。 
        System.out.println("helloworld");
        t.cancel();//当任务被执行完毕以后，关闭定时器
    }
}

案例2：定时删除文件
所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务

package com.edu_12;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class Test {
    public static void main(String[] args) throws Exception {
        /* 案例2：定时删除文件(须要在16：30：00 删除D：//a.txt文件) * 所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务 * 时间点：16：30：00 * 任务：删除D：//a.txt文件 */
        //建立定时器
        Timer t = new Timer();
        String time = "2019-05-20 16:30:00";
        Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time);
        //所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务
        t.schedule(new MyTimerTask(), date);
    }
}
class MyTimerTask extends TimerTask{
    @Override
    public void run() {
        //任务：删除D：//a.txt文件
        File file = new File("D://a.txt");
        file.delete();
    }
}

多线程相关题：

1.多线程有几种实现方案，分别是哪几种?
有俩种实现方案：（1）实现Runnable（）接口；（2）继承Thread（）类

2.同步有几种方式，分别是什么?
同步有三种方式：（1）同步代码块；（2）同步方法；（3）静态同步方法

3.启动一个线程是run()仍是start()?它们的区别?
启动线程利用start（），run（）方法指的是对象调方法，在主线程里面执行该方法，start（）指的是开启线程，在线程里面执行该方法

4.sleep()和wait()方法的区别：
sleep（）：线程休眠，必定会醒来，并且线程在休眠的时候，不会放下本身手中的锁
wait（）：线程等待，线程等待的时候会放下本身手中的锁，线程等待须要唤醒，不唤醒，不执行

5.为何wait(),notify(),notifyAll()等方法都定义在Object类中？
这些方法存在于同步中，使用这些方法的时候，必须代表所属的锁，锁能够是任意对象，可是必须保证是同一把锁，因此这些方法都定义在Object（）中

Java多线程（一）：
https://blog.csdn.net/Veer_c/article/details/103842078
Java多线程（二）：
https://blog.csdn.net/Veer_c/article/details/103842263
Java多线程（三）：
https://blog.csdn.net/Veer_c/article/details/103842317
Java多线程（四）： https://blog.csdn.net/Veer_c/article/details/103842602