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
线程组
线程组:Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。默认情况下,所有的线程都属于主线程组。
public final ThreadGroup getThreadGroup():获取线程对应的线程组对象,我们也可以给线程设置分组。
Thread(ThreadGroup group, Runnable target)
案例1:创建线程获取对应的线程组对象,并获取名称
案例2:创建线程组对象,给线程分配线程组
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内置支持线程池
线程池如何创建?
JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
public static ExecutorService newFixedThreadPool(int nThreads)
线程池的使用步骤:
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接口实现线程池的使用
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接口实现线程池的使用
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() 取消这个任务
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