1:多线程(理解)
(1)JDK5以后的针对线程的锁定操作和释放操作
Lock锁
* 虽然我们可以理解同步代码块和同步方法的锁对象问题,但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,
* 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock。
*
* Lock:
* void lock(): 获取锁。
* void unlock():释放锁。
* ReentrantLock是Lock的实现类.
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SellTicket implements Runnable {
// 定义票
private int tickets = 100;
// 定义锁对象
private Lock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
// 加锁
lock.lock();
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "正在出售第" + (tickets--) + "张票");
}
} finally {
// 释放锁
lock.unlock();
}
}
}
}
(2)死锁问题的描述和代码体现
public class DieLock extends Thread {
private boolean flag;
public DieLock(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag) {
synchronized (MyLock.objA) {
System.out.println("if objA");
synchronized (MyLock.objB) {
System.out.println("if objB");
}
}
} else {
synchronized (MyLock.objB) {
System.out.println("else objB");
synchronized (MyLock.objA) {
System.out.println("else objA");
}
}
}
}
}
/*
* 同步的弊端:
* A:效率低
* B:容易产生死锁
*
* 死锁:
* 两个或两个以上的线程在争夺资源的过程中,发生的一种相互等待的现象。
*
* 举例:
* 中国人,美国人吃饭案例。
* 正常情况:
* 中国人:筷子两支
* 美国人:刀和叉
* 现在:
* 中国人:筷子1支,刀一把
* 美国人:筷子1支,叉一把
*/
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();
}
(3)生产者和消费者多线程体现(线程间通信问题)
资源类:Student
设置数据类:SetThread(生产者)
获取数据类:GetThread(消费者)
测试类:StudentDemo
代码:
A:最基本的版本,只有一个数据。
B:改进版本,给出了不同的数据,并加入了同步机制
C:等待唤醒机制改进该程序,让数据能够实现依次的出现
wait() 等待
notify() 唤醒单个线程
notifyAll() (多生产多消费) 唤醒所有线程
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Student
{
// String name;
// int age;
// boolean flag;
private String name;
private int age;
private boolean flag;
public synchronized void set(String name, int age)
{
if (this.flag)
{
try
{
this.wait();
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
this.name = name;
this.age = age;
this.flag = true;
this.notify();
}
public synchronized void get()
{
if (!this.flag)
{
try
{
this.wait();
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
System.out.println(this.name + "===" + this.age);
this.flag = false;
this.notify();
}
}
class Producer implements Runnable
{
Student s;
Producer(Student s)
{
this.s = s;
}
int x = 0;
@Override
public void run()
{
while (true)
{
// synchronized (s) {
// if (s.flag) {
// try {
// s.wait();
// } catch (InterruptedException e) {
//
// e.printStackTrace();
// }
// }
if (x % 2 == 0)
{
// s.name = "张三";
// s.age = 21;
s.set("张三", 21);
x++;
} else
{
// s.name = "渣渣";
// s.age = 1;
s.set("渣渣", 1);
x++;
}
// s.flag = true;
// s.notify();
// }
//
}
}
}
class Consumer implements Runnable
{
Student s;
Consumer(Student s)
{
this.s = s;
}
@Override
public void run()
{
while (true)
{
// synchronized (s) {
// if (!s.flag) {
// try {
// s.wait();
// } catch (InterruptedException e) {
//
// e.printStackTrace();
// }
// }
// System.out.println(s.name + "==" + s.age);
//
// s.flag = false;
// s.notify();
// }
s.get();
}
}
}
public class TestWaitNotify
{
public static void main(String[] args)
{
// ThreadGroup tg= new ThreadGroup("线程组");
Student s = new Student();
// Producer pro = new Producer(s);
// Consumer con = new Consumer(s);
// Thread t1 = new Thread(tg,pro,"线程1");
// Thread t2 = new Thread(tg,con,"线程2");
// t1.getThreadGroup().getName();
//
//
// t1.start();
// t2.start();
//线程池
ExecutorService pool=Executors.newFixedThreadPool(2);
pool.submit(new Producer(s));
pool.submit(new Consumer(s));
//结束线程池
pool.shutdown();
}
}
为什么这些方法不定义在Thread类中呢?
* 这些方法的调用必须通过锁对象调用,而我们刚才使用的锁对象是任意锁对象。
* 所以,这些方法必须定义在Object类中。
(4)线程组
* 线程组: 把多个线程组合到一起。
* 它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
// 我们如何修改线程所在的组呢?
// 创建一个线程组
// 创建其他线程的时候,把其他线程的组指定为我们自己新建线程组
(5)线程池
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}
}
import java.util.concurrent.Callable;
//Callable:是带泛型的接口。
//这里指定的泛型其实是call()方法的返回值类型。
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;
}
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/*
* 线程池的好处:线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
*
* 如何实现线程的代码呢(多线程实现第三种方法)?
* A:创建一个线程池对象,控制要创建几个线程对象。
* public static ExecutorService newFixedThreadPool(int nThreads)
* B:这种线程池的线程可以执行:
* 可以执行Runnable对象或者Callable对象代表的线程
* 做一个类实现Runnable接口。
* C:调用如下方法即可
* Future<?> submit(Runnable task)
* <T> Future<T> submit(Callable<T> task)
* D:我就要结束,可以吗?
* 可以。
*/
public class ExecutorsDemo {
public static void main(String[] args) {
// 创建一个线程池对象,控制要创建几个线程对象。
// public static ExecutorService newFixedThreadPool(int nThreads)
ExecutorService pool = Executors.newFixedThreadPool(2);
// 可以执行Runnable对象或者Callable对象代表的线程
pool.submit(new MyRunnable());
pool.submit(new MyRunnable());
//结束线程池
pool.shutdown();
}
}
(6)多线程实现的第三种方案
匿名内部类方式开线程
/*
* 匿名内部类的格式:
* new 类名或者接口名() {
* 重写方法;
* };
* 本质:是该类或者接口的子类对象。
*/
public class ThreadDemo {
public static void main(String[] args) {
// 继承Thread类来实现多线程
new Thread() {
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + ":"
+ x);
}
}
}.start();
// 实现Runnable接口来实现多线程
new Thread(new Runnable() {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName() + ":"
+ x);
}
}
}) {
}.start();
// 更有难度的
new Thread(new Runnable() {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println("hello" + ":" + x);
}
}
}) {
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println("world" + ":" + x);
}
}
}.start();
}
}
定时器
import java.util.Timer;
import java.util.TimerTask;
/*
* 定时器:可以让我们在指定的时间做某件事情,还可以重复的做某件事情。
* 依赖Timer和TimerTask这两个类:
* Timer:定时
* public Timer()
* public void schedule(TimerTask task,long delay)
* public void schedule(TimerTask task,long delay,long period)
* public void cancel()
* TimerTask:任务
*/
public class TimerDemo {
public static void main(String[] args) {
// 创建定时器对象
Timer t = new Timer();
// 3秒后执行爆炸任务
// t.schedule(new MyTask(), 3000);
//结束任务
t.schedule(new MyTask(t), 3000);
}
}
// 做一个任务
class MyTask extends TimerTask {
private Timer t;
public MyTask(){}
public MyTask(Timer t){
this.t = t;
}
@Override
public void run() {
System.out.println("beng,爆炸了");
t.cancel();
}
}
(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:经验的总结
创建型
结构型
行为型
(3)改进的设计模式
A:简单工厂模式
B:工厂方法模式
C:单例模式(掌握)
* 单例模式:保证类在内存中只有一个对象。
*
* 如何保证类在内存中只有一个对象呢?
* A:把构造方法私有
* B:在成员位置自己创建一个对象
* C:通过一个公共的方法提供访问
*/
a:饿汉式
public class Student {
// 构造私有
private Student() {
}
// 自己造一个
// 静态方法只能访问静态成员变量,加静态
// 为了不让外界直接访问修改这个值,加private
private static Student s = new Student();
// 提供公共的访问方式
// 为了保证外界能够直接使用该方法,加静态
public static Student getStudent() {
return s;
}
}
b:懒汉式
/*
* 单例模式:
* 饿汉式:类一加载就创建对象
* 懒汉式:用的时候,才去创建对象
*
* 面试题:单例模式的思想是什么?请写一个代码体现。
*
* 开发:饿汉式(是不会出问题的单例模式)
* 面试:懒汉式(可能会出问题的单例模式)
* A:懒加载(延迟加载)
* B:线程安全问题
* a:是否多线程环境 是
* b:是否有共享数据 是
* c:是否有多条语句操作共享数据 是
*/
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;
}
}
(4)Runtime
* Runtime:每个 Java 应用程序都有一个 Runtime 类实例,使应用程序能够与其运行的环境相连接。
* exec(String command)
还可以调用dos命令。