一:线程中的一些方法(线程中存在的现象)
A.线程加入
public final void join()
等待该线程中止,其他线程才能继续抢着执行 。
MyThread.java
package com.study_01;
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println(this.getName()+"--- "+i);
}
}
}
Test.java
package com.study_01;
/**
* 线程加入
public final void join()
等待该线程中止,其他线程才能继续抢着执行
* @author dell
*
*/
public class Test {
public static void main(String[] args) {
//创建三个线程
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
//给三个线程命名
t1.setName("关羽");
t2.setName("刘备");
t3.setName("曹操");
//开启线程,并且让t1先执行
t1.start();
try {
t1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t2.start();
t3.start();
}
}
可通过运算结果的执行了解该方法的调用。
B.线程礼让
public static void yield():暂停当前正在执行的线程对象,并执行其他线程。
作用:让线程间的执行更和谐一些,但是实际上做不到。可以通过后面讲解的知识来实现。
MyThread.java
package com.study_02;
public class MyThread extends Thread{
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println(this.getName()+"--"+i);
//再调用run方法的时候实现线程礼让
Thread.yield();
}
}
}
Test.java
package com.study_02;
/**
* public static void yield():暂停当前正在执行的线程对象,并执行其他线程。
作用:让线程间的执行更和谐一些,但是实际上做不到。可以通过后面讲解的知识来实现。
* @author dell
*
*/
public class Test {
public static void main(String[] args) {
//创建三个线程
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
MyThread mt3 = new MyThread();
//给线程命名
mt1.setName("贾宝玉");
mt2.setName("林黛玉");
mt3.setName("薛宝钗");
//开启线程
mt1.start();
mt2.start();
mt3.start();
}
}
C.线程死亡
public final void stop():直接杀死
public void interrupt():直接杀死,在死前,还可以有遗言。
Mythread.java
package com.study_03;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MyThread extends Thread{
@Override
public void run() {
System.out.println("开始时间为:"+ new SimpleDateFormat("HH:mm:ss").format(new Date()));
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
System.out.println("我被杀死了");
}
System.out.println("结束时间为:"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
Test.java
package com.study_03;
/**
* public final void stop():直接杀死
public void interrupt():直接杀死,在死前,还可以有遗言。
* @author dell
*
*/
public class Test {
public static void main(String[] args) {
//创建线程
MyThread t = new MyThread();
//开启线程
t.start();
try {
//在线程睡眠2s的时候将它杀死
t.sleep(2000);
//t.stop();//直接就死掉了,不给任何说话的机会
t.interrupt();//还可以继续执行程序,执行完在死
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
D.线程休眠
static void sleep(long millis) 线程睡一会
二:线程的生命周期(画图讲解),面试题
1.新建
2.就绪
3.运行
4.有可能阻塞
5.死亡
三:线程间通信(生产消费者问题):不同类型线程针对同一个资源的操作画图讲解:
A.系统不仅要卖票还要入票
B.不仅要卖肉夹馍还要生产肉夹馍
四:案例:以给学生设置和获取姓名和年龄为例,演示线程通信问题线程间通讯:
方法:A.私有化Student类的成员变量
B.在类的内部提供设置和获取的同步方法
资源:Student.java
package com.study_06;
public class Student {
//定义学生属性
private String name;
private int age;
private boolean flag;
//将设置线程中的的功能封装为一个方法
public synchronized void setInfo(String name,int age){
while(true){
if(this.flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//设置姓名和年龄
this.name="谢娜";
this.age=30;
//更改标记,唤醒获取数据开始获取
this.flag=true;
this.notify();
}
}
}
//将获取线程中的功能封装为一个方法
public synchronized void getInfo(){
while(true){
if(!this.flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(this.name+"--"+this.age);
this.flag=false;
this.notify();
}
}
}
}
设置数据线程:SetThread.java
package com.study_06;
public class SetThread implements Runnable {
private Student s;
private int x;
public SetThread(Student s){
this.s=s;
}
@Override
public void run() {
synchronized (s) {
while(true){
if(x%2==0){
s.setInfo("谢娜", 30);
}else{
s.setInfo("张杰", 28);
}
x++;
}
}
}
}
获取数据线程:GetThread.java
package com.study_06;
public class GetThread implements Runnable {
private Student s;
public GetThread(Student s){
this.s=s;
}
@Override
public void run() {
while(true){
s.getInfo();
}
}
}
测试类:StudentTest.java
package com.study_06;
public class StudentTest {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//创建俩个线程
SetThread st1 = new SetThread(s);
GetThread gt2 = new GetThread(s);
Thread t1 = new Thread(st1);
Thread t2 = new Thread(gt2);
//开启线程
t1.start();
t2.start();
}
}
五:线程组
线程组:Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
默认情况下,所有的线程都属于主线程组。
public final ThreadGroup getThreadGroup():获取线程对应的线程组对象
我们也可以给线程设置分组
Thread(ThreadGroup group, Runnable target)
案例1:创建线程获取对应的线程组对象,并获取名称
案例2:创建线程组对象,给线程分配线程组
MyRunnable.java
package com.study_07;
public class MyRunnable implements Runnable{
@Override
public void run() {
}
}
MyThread.java
package com.study_07;
public class MyThread extends Thread{
@Override
public void run() {
}
}
Test.java
package com.study_07;
public class Test {
public static void main(String[] args) {
//案例1:创建线程获取对应的线程组对象,并获取名称
//创建线程对象
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
//获取线程组对象
ThreadGroup t1 = mt1.getThreadGroup();
ThreadGroup t2 = mt2.getThreadGroup();
//获取线程组名称
System.out.println(t1.getName());
System.out.println(t2.getName());
System.out.println("------------------------");
//案例2:创建线程组对象
ThreadGroup tg = new ThreadGroup("吴亦凡");
//分配新的线程组对象
Thread tt1 = new Thread(tg, new MyRunnable());
Thread tt2 = new Thread(tg, new MyRunnable());
//获取线程组对象
ThreadGroup tg1 = tt1.getThreadGroup();
ThreadGroup tg2 = tt2.getThreadGroup();
//获取线程组名称
System.out.println(tg1.getName());
System.out.println(tg2.getName());
}
}
六:线程池
A.为什么要使用线程池?
程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
B.线程池的特点:
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池
C.线程池如何创建?
JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法public static ExecutorService newFixedThreadPool(int nThreads)
D.线程池的使用步骤:
1.创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);
2.创建Runnable实例
MyRunnable my = new MyRunnable();
3.提交Runnable实例
pool.submit(my);
pool.submit(my);
4.关闭线程池
pool.shutdown();
案例:实现Callable接口实现线程池的使用,实现多线程求和,1-10之和,1-100之和。
MyCallable.java
package com.study_10;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<Integer>{//这里的泛型就是返回值的类型
private int start;
private int end;
public MyCallable(int start,int end){
this.start=start;
this.end=end;
}
@Override
public Integer call() throws Exception {
int sum=0;
for(int i=0;i<end+1;i++){
sum+=i;
}
return sum;
}
}
Test.java
package com.study_10;
//案例3:实现Callable接口实现线程池的使用,实现多线程求和,1-10之和,1-100之和
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 {
//创建线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//创建任务
MyCallable mc1 = new MyCallable(1, 10);
MyCallable mc2 = new MyCallable(1, 100);
//提交任务
Future<Integer> s1 = pool.submit(mc1);
Future<Integer> s2 = pool.submit(mc2);
//输出结果
System.out.println(s1.get());
System.out.println(s2.get());
//关闭线程池
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()放的是所要执行的任务代码
案例:定时删除文件
所用方法:schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务
package com.study_12;
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
* 案例2:定时删除文件(需要在19:08:00 删除D://a.txt文件)
* 所用方法:schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务
* 时间点:19:08:00
* 任务:删除D://a.txt文件
*/
public class TimerTest {
public static void main(String[] args) throws Exception {
//创建一个定时器
Timer t = new Timer();
String time="2017-5-23 19:08:00";
Date date = new SimpleDateFormat("yyyy-MM-dd hh:MM:ss").parse(time);
t.schedule(new MyTaskTest(), date);
}
}
class MyTaskTest extends TimerTask {
@Override
public void run() {
File file = new File("d:\\a.txt");
file.delete();
}
}