学习笔记_JavaSE_24-JDK1.5LOCK锁、生产消费者案例、线程池组、设计模式

1:多线程(理解)
(1)JDK5以后的 针对线程的锁定操作和释放操作
Lock锁
 * void lock()： 获取锁。 加锁
 * void unlock():释放锁。  
 * ReentrantLock是Lock的实现类.
 
(2)死锁问题的描述和代码体现
* 死锁：两个或两个以上的线程在争夺资源的过程中，发生的一种相互等待的现象。
public class DieLockDemo {
public static void main(String[] args) {
DieLock dl1 = new DieLock(true);
DieLock dl2 = new DieLock(false);


dl1.start();
dl2.start();
}
}

public class MyLock {
// 创建两把锁对象
public static final Object objA = new Object();
public static final Object objB = new Object();
}

public class DieLock extends Thread {


private boolean flag;  //将来造DieLock对象的时候，把flag标记给改了


public DieLock(boolean flag) {
this.flag = flag;
}


@Override
public void run() {
if (flag) { //A线程的flag是ture,走这里
synchronized (MyLock.objA) {
System.out.println("if objA");
synchronized (MyLock.objB) {
System.out.println("if objB");
}
}
} else { //B线程的flag是false,走这里
synchronized (MyLock.objB) {
System.out.println("else objB");
synchronized (MyLock.objA) {
System.out.println("else objA");
}
}
}
}
}
(3)生产者和消费者多线程体现(线程间通信问题)   生产者和消费者问题
以学生作为资源来实现的

资源类： Student
设置数据类：SetThread(相当于生产者)
获取数据类：GetThread(相当于消费者)
测试类： StudentDemo

代码：
A:最基本的版本，只有一个数据。
B:改进版本，给出了不同的数据，并加入了同步机制
C:等待唤醒机制改进该程序，让数据能够实现：依次的出现
wait()
notify()
notifyAll() (用在：多生产多消费)
D:等待唤醒机制的代码优化。 把数据及操作，都写在了资源类中

(4)线程组
public class ThreadGroupDemo {
public static void main(String[] args) {

// method1();


// 我们如何修改线程所在的组呢?
// 创建一个线程组
// 在创建其他线程的时候，把其他线程的组,指定为我们自己新建线程组
method2();



}


private static void method2() {
// ThreadGroup(String name)
ThreadGroup tg = new ThreadGroup("这是一个新的组");


MyRunnable my = new MyRunnable();
// Thread(ThreadGroup group, Runnable target, String name)
Thread t1 = new Thread(tg, my, "林青霞");
Thread t2 = new Thread(tg, my, "刘意");

System.out.println(t1.getThreadGroup().getName());
System.out.println(t2.getThreadGroup().getName());

//通过组名称设置后台线程(守护线程)，表示该组的线程都是后台线程(守护线程)
tg.setDaemon(true);
}


private static void method1() {
MyRunnable my = new MyRunnable();
Thread t1 = new Thread(my, "林青霞");
Thread t2 = new Thread(my, "刘意");
// 我不知道他们属于哪个线程组,我想知道，怎么办
// 线程类里面的方法：public final ThreadGroup getThreadGroup()
ThreadGroup tg1 = t1.getThreadGroup();
ThreadGroup tg2 = t2.getThreadGroup();
// 线程组里面的方法：public final String getName()
String name1 = tg1.getName();
String name2 = tg2.getName();
System.out.println(name1);
System.out.println(name2);
// 通过结果,我们知道了：线程默认情况下，属于main线程组
// 通过下面的测试，你应该能够看到，默任情况下，所有的线程都属于同一个组:main线程组
System.out.println(Thread.currentThread().getThreadGroup().getName());
}
}

public class MyRunnable implements Runnable {


@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}


}


(5)线程池
JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
public static ExecutorService newCachedThreadPool()
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newSingleThreadExecutor()   第2个参数为1


(6)多线程实现的第三种方案   依赖线程池存在的   了解即可
public class MyCallable implements Callable {
@Override
public Object call() throws Exception {
for(int x=0;x<100;x++) {
System.out.println(Thread.currentThread().getName()+":"+x);
}
return null;
}
}
public class CallableDemo {
public static void main(String[] args) {
//创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(2);

//可以执行Runnable对象或者Callable对象代表的线程
pool.submit(new MyCallable());
pool.submit(new MyCallable());
//结束
pool.shutdown();
}
}

(7)多线程的面试题
1:多线程有几种实现方案，分别是哪几种?
两种。

继承Thread类
实现Runnable接口

扩展一种：实现Callable接口。这个得和线程池结合。


2:同步有几种方式，分别是什么?
两种。

同步代码块
同步方法


3:启动一个线程是run()还是start()?它们的区别?
start();

run():封装了被线程执行的代码,直接调用仅仅是普通方法的调用
start():启动线程，并由JVM自动调用run()方法


4:sleep()和wait()方法的区别
sleep():必须指定时间; 不释放锁。 即使有人想进来，它也进不来，
wait(): 可以不指定时间，也可以指定时间; 释放锁。  就得把锁给别人，不然别人用不了


5:为什么wait(),notify(),notifyAll()等方法都定义在Object类中
因为这些方法的调用是依赖于锁对象的，而同步代码块的锁对象是任意锁。
而Object代表任意的对象，所以，定义在这里面。


6:线程的生命周期图
新建 -- 就绪 -- 运行 -- 死亡
新建 -- 就绪 -- 运行 -- 阻塞 -- 就绪 -- 运行 -- 死亡
建议：画图解释。


2:设计模式(理解)
(1)面向对象的常见设计原则     所有的原则都是让我们做到高内聚低耦合，为了提高我们程序的维护性，扩展性，复用性
单一
开闭
里氏
依赖注入
接口
迪米特

(2)设计模式概述和分类
A:经验的总结
B:三类
创建型
结构型
行为型

(3)常见的设计模式
A:简单工厂模式

B:工厂方法模式

C:单例模式(掌握代码及思想)
a:饿汉式
public class Teacher {
private Teacher() {
}


private static Teacher t = null;


public synchronized static Teacher getTeacher() {
// 假设走到这，我有三个线程t1,t2,t3
if (t == null) {
//t1,t2,t3
t = new Teacher(); //懒汉式:用的时候，才去创建对象
}
return t;
}
}

public class TeacherDemo {
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher(); //只有第1次才造对象   因为静态  共享的
Teacher t2 = Teacher.getTeacher();//第2次不造对象
System.out.println(t1 == t2);
System.out.println(t1); // cn.itcast_03.Teacher@175078b
System.out.println(t2);// cn.itcast_03.Teacher@175078b
}
}

b:懒汉式
public class Student {
// 构造私有
private Student() {
}


// 自己造一个
// 静态方法只能访问静态成员变量，加静态
// 为了不让外界直接访问修改这个值，加private
private static Student s = new Student();  //饿汉式  一进来就造对象


// 提供公共的访问方式  提供一个静态方法，返回该对象
// 为了保证外界能够直接使用该方法，加静态
public static Student getStudent() {
return s;
}
}

public class StudentDemo {
public static void main(String[] args) {
// Student s1 = new Student();
// Student s2 = new Student();
// System.out.println(s1 == s2); // false


// 通过单例如何得到对象呢?


// Student.s = null;


Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1 == s2);//true
//加了private后
System.out.println(s1); // null， cn.itcast_03.Student@175078b
System.out.println(s2);// null， cn.itcast_03.Student@175078b
}
}
(4)Runtime
JDK提供的一个单例模式应用的类。
还可以调用dos命令。