一：死锁
1、概述
指的是两个或者两个以上线程在执行过程中，因为争夺资源产生的一种互相等待的现象。
2、注意
死锁的现象更容易出现在同步嵌套的情况，所以今后开发的时候，尽量避免同步嵌套
二：线程间通信
1、注意
在外界创建出来一个学生对象，通过参数的形式让两个线程操作同一个对象，通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作
不同种类的线程对象都需要加锁 ，且必须是同一把锁。
通过等待唤醒机制实现数据依次出现，实现生产和消费依次进行
如何添加等待唤醒机制呢？
所需要调用的方法在Object类中，Object类中有三个方法需要我们学习。
void notify()
唤醒正在等待对象监视器的单个线程。
void notifyAll()
唤醒正在等待对象监视器的所有线程。
void wait()
导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
public class Student {
String name;
int age;
boolean flag;
}
public class SetThread implements Runnable {
private Student s;
private int i = 0;
SetThread(Student student) {
s = student;
}
@Override
public void run() {
s.name = "王宇";
s.age = 18;
while (true) {
synchronized (s){
//判断学生对象有没有值
//flag初始的时候值是false,表示没有值，如果是true表示生产者已经生产了值
//有值对于生产者来说，等待消费者消费数据
if(s.flag){
try {
s.wait(); // 阻塞，等待消费者消费数据，才能继续往下走
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (i % 2 == 0) {
s.name = "王宇";
s.age = 18;
} else {
s.name = "张保桂";
s.age = 19;
}
i++;
//生产者生产完数据后，将flag值改为true
//通知消费者消费数据
s.notify();
s.flag = true;
}
}
}
}public class GetThread implements Runnable {
private Student s;
GetThread(Student student) {
s = student;
}
@Override
public void run() {
while (true){
synchronized (s){
//判断学生对象的成员变量是否有值
//如果flag的值是true，表示可以进行取值，反之，等待生产者生产数据
if(!s.flag){
try {
s.wait(); //阻塞 等待生产者生产数据
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(s.name + "---" + s.age);
//消费者消费完数据后，通知生产者生产数据
s.notify();
s.flag = false;
}
}
}
}public class StudentDemo {
public static void main(String[] args) {
Student s = new Student();
SetThread setThread = new SetThread(s);
GetThread getThread = new GetThread(s);
//使用Thread类创建线程对象，将自定义对象作为参数传递
Thread proThread = new Thread(setThread);
Thread cusThread = new Thread(getThread);
//启动线程
proThread.start();
cusThread.start();
}
}三、线程组
Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
默认情况下，所有的线程都属于主线程组（main） public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组 Thread(ThreadGroup group, Runnable target, String name)
public static void main(String[] args) {
//创建自定义对象
MyRunnable myRunnable = new MyRunnable();
//通过Thread类创建的多个线程对象
Thread t1 = new Thread(myRunnable,"王宇");
Thread t2 = new Thread(myRunnable,"张保桂");
//默认情况下，所有的线程都属于主线程组。
//public final ThreadGroup getThreadGroup()
ThreadGroup tg1 = t1.getThreadGroup();
System.out.println(tg1);
ThreadGroup tg2 = t2.getThreadGroup();
System.out.println(tg2);
//如何线程组的名字
//public final String getName()返回此线程组的名称。
String s1 = tg1.getName();
String s2 = tg2.getName();
System.out.println(s1);
System.out.println(s2);
System.out.println(s1.equals(s2));
//需求：给线程分组
//Thread(ThreadGroup group, Runnable target, String name)
//分配一个新的 Thread对象，使其具有 target作为其运行对象，具有指定的 name作为其名称，属于 group引用的线程组。
//创建一个新的线程组
//ThreadGroup(String name)
//构造一个新的线程组。
ThreadGroup tg3 = new ThreadGroup("帅哥组");
//创建线程对象并分组
Thread t3 = new Thread(tg3, myRunnable, "李煜阳");
Thread t4 = new Thread(tg3, myRunnable, "小虎");
Thread t5 = new Thread(tg3, myRunnable, "刘志城");
//获取到目前位置所有线程的名字以及所属线程组的名字
System.out.println(t1.getName()+"属于线程组："+t1.getThreadGroup().getName());
System.out.println(t2.getName()+"属于线程组："+t2.getThreadGroup().getName());
System.out.println(t3.getName()+"属于线程组："+t3.getThreadGroup().getName());
System.out.println(t4.getName()+"属于线程组："+t4.getThreadGroup().getName());
System.out.println(t5.getName()+"属于线程组："+t5.getThreadGroup().getName());
//Java允许程序直接对线程组进行控制。
//需求：将一个组内的所有线程设置为守护线程
//直接通过组名进行设置，组里面的线程都是属于守护线程
tg3.setDaemon(true);
}四、线程池
程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
public static void main(String[] args) {
//创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);//2表示一个有2个线程的线程池
//Future<?> submit(Runnable task)
//提交一个可运行的任务执行，并返回一个表示该任务的未来。
//提交即运行
MyRunnable myRunnable = new MyRunnable();
pool.submit(myRunnable); //底层封装成了一个线程对象并启动执行
pool.submit(myRunnable);
//提交的线程数超过线程池的数量也会执行，只不过是当有空闲线程位置的时候再去执行
pool.submit(myRunnable);
//我想结束线程的运行，可不可以手动结束呢？如果可以，怎么结束？
//void shutdown()
//启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
pool.shutdown();
//RejectedExecutionException：拒绝执行异常
//线程池已经被关闭了，不能再继续提交任务
pool.submit(myRunnable);
}五、多线程实现方式（三）
自定义类实现Callable接口，实现call方法，call方法内要返回任意Object类的对象。
该线程的启动必须与线程池结合，单独无法创建线程对象启动
import java.util.concurrent.Callable;
public class MyCallable implements Callable {
@Override
public Object call() throws Exception {
Object o = new Object();
for (int i = 1; i <= 200; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
return o;
}
}
public class ThreadPoolDemo2 {
public static void main(String[] args) {
//创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);
//创建自定义Callable对象
MyCallable myCallable = new MyCallable();
//提交到线程池中执行
pool.submit(myCallable);
//手动停止线程池,
pool.shutdown();
}
}实现多线程的方法有三种：继承Thread类，实现Runable接口、实现Callable接口
六、使用匿名内部类实现多线程
public class ThreadDemo2 {
public static void main(String[] args) {
//1、继承Thread类，重写run方法，start()启动线程
new Thread("王宇") {
@Override
public void run() {
for (int i = 1; i <= 200; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}.start();
//2、实现Runnable接口，实现run方法
new Thread(new Runnable(){
@Override
public void run() {
for (int i = 1; i <= 200; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
},"小虎").start();
}
}
七、定时器
定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。在Java中，可以通过Timer和TimerTask类来实现定义调度的功能
public class TimerDemo {
public static void main(String[] args) {
//创建定时器对象
//Timer() 创建一个新的计时器。
Timer timer = new Timer();
//调度任务执行
//void schedule(TimerTask task, long delay)
//在指定的延迟之后安排指定的任务执行。
timer.schedule(new MyTask(timer),3000);//3秒后在启动
}
}
class MyTask extends TimerTask{
private Timer timer;
public MyTask(Timer timer){
this.timer = timer;
}
@Override
public void run() {
System.out.println("beng!!!!爆炸了");
timer.cancel();//停止程序
}
}public class TimerDemo2 {
public static void main(String[] args) {
//创建定时器对象
Timer timer = new Timer();
//void schedule(TimerTask task, long delay, long period)
//在指定 的延迟之后开始 ，重新执行 固定延迟执行的指定任务。
//3秒后执行任务，并且之后每隔两秒执行一次
timer.schedule(new MyTask2(),3000,2000);
}
}
class MyTask2 extends TimerTask{
@Override
public void run() {
try {
FileReader fr = new FileReader("ss.txt");
BufferedReader br = new BufferedReader(fr);
String s = br.readLine();
System.out.println(s);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
