Java基础之多线程(二)
2016-03-10 13:45
501 查看
五、JDK5中Lock锁的使用
虽然我们可以理解同步代码块和同步方法的锁对象问题,
但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,
为了更清晰的表达如何加锁和释放锁,
JDK5以后提供了一个新的锁对象Lock
Lock
void lock() :获取锁
void unlock():释放锁
ReentrantLock 是Lock的实现类.
六、 死锁
1.同步弊端
效率低
如果出现了同步嵌套,就容易产生死锁问题
2.死锁问题及其代码
是指两个或者两个以上的线程在执行的过程中,因争夺资源产生的一种互相等待现象
七、线程间的通信
针对同一个资源的操作有不同种类的线程
举例:卖票有进的,也有出的。
通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作
虽然通过同步机制线程的安全问题解决了,但是一样存在着下面的问题
1.如果消费者先抢到CPU的执行权,就会消费数据,但是现在的数据是默认值,
没有意义,应该等着数据的产生,再消费
2.如果生产者先抢到CPU的执行权,就回去产生数据,但是,它产生完数据后,还继续拥有执行权,
它又继续产生数据,这是有问题的,应该等着消费者把数据消费掉,然后再生产。
正常思路:
A:生产者
先看是否有数据,有就等待,没有就生产,生产完之后通知消费者来消费数据
B:消费者
先看是否有数据,有就消费,没有就等待,通知生产者生产数据
为了处理这样的问题,Java就提供了一种机制,等待唤醒机制
生产者与消费者的示例
八、线程组
Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
默认情况下所有的线程都属于主线程组
public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组
Thread(ThreadGroup group, Runnable target, String name)
如何修改线程所在的组呢?
创建一个线程组
创建其他线程的时候,把其他线程的组指定为我们自己新建线程组
九、线程池
1.程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。
而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池。
JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
public static ExecutorService newCachedThreadPool():创建一个具有缓存功能的线程池
public static ExecutorService newFixedThreadPool(int nThreads):创建一个可重用的,具有固定线程数的线程池
public static ExecutorService newSingleThreadExecutor():创建一个只有单线程的线程池,相当于上个方法的参数是1
这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
Future<?> submit(Runnable task)
<T> Future<T> submit(Callable<T> task)
2.如何实现线程池的代码呢?
A:创建一个线程池对象,控制要创建几个线程对象。
public static ExecutorService newFixedThreadPool(int nThreads)
B:这种线程池的线程可以执行:
可以执行Runnable对象或者Callable对象代表的线程
做一个类实现Runnable接口。
C:调用如下方法即可
Future<?> submit(Runnable task)
<T> Future<T> submit(Callable<T> task)
D:可以结束线程池
十、匿名内部类方式使用多线程
匿名内部类的格式:
new 类名或者接口名() {
重写方法;
};
本质:是该类或者接口的子类对象。
new Thread(){
代码…
}.start();
new Thread(new Runnable(){
代码…
}).start();
定时器是一个应用十分广泛的线程工具,可用于调度多个定时任务以后台线程的方式执行。
在Java中,可以通过Timer和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 abstract void run():此计时器任务要执行的操作。
public boolean cancel():取消此计时器任务。
开发中
Quartz是一个完全由java编写的开源调度框架。
十二、设计模式之单例设计模式
单例设计思想
保证类在内存中只有一个对象
如何实现类在内存中只有一个对象呢?
构造私有
本身提供一个对象
通过公共的方法让外界访问
单例模式:
饿汉式:类一加载就创建对象
懒汉式:用的时候,才去创建对象
面试题:单例模式的思想是什么?请写一个代码体现。
开发:饿汉式(是不会出问题的单例模式)
面试:懒汉式(可能会出问题的单例模式)
A:懒加载(延迟加载)
B:线程安全问题
a:是否多线程环境
是
b:是否有共享数据
是
c:是否有多条语句操作共享数据
是
解决方式:同步函数
十三、多线程中常见的面试题
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:线程的生命周期图
新建 -- 就绪 -- 运行 -- 死亡
新建 -- 就绪 -- 运行 -- 阻塞 -- 就绪 -- 运行 -- 死亡
虽然我们可以理解同步代码块和同步方法的锁对象问题,
但是我们并没有直接看到在哪里加上了锁,在哪里释放了锁,
为了更清晰的表达如何加锁和释放锁,
JDK5以后提供了一个新的锁对象Lock
Lock
void lock() :获取锁
void unlock():释放锁
ReentrantLock 是Lock的实现类.
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(); } } } } public class SellTicketDemo { public static void main(String[] args) { // 创建资源对象 SellTicket st = new SellTicket(); // 创建三个窗口 Thread t1 = new Thread(st, "窗口1"); Thread t2 = new Thread(st, "窗口2"); Thread t3 = new Thread(st, "窗口3"); // 启动线程 t1.start(); t2.start(); t3.start(); } }
六、 死锁
1.同步弊端
效率低
如果出现了同步嵌套,就容易产生死锁问题
2.死锁问题及其代码
是指两个或者两个以上的线程在执行的过程中,因争夺资源产生的一种互相等待现象
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; 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"); } } } } } public class DieLockDemo { public static void main(String[] args) { DieLock dl1 = new DieLock(true); DieLock dl2 = new DieLock(false); dl1.start(); dl2.start(); } }
七、线程间的通信
针对同一个资源的操作有不同种类的线程
举例:卖票有进的,也有出的。
通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作
虽然通过同步机制线程的安全问题解决了,但是一样存在着下面的问题
1.如果消费者先抢到CPU的执行权,就会消费数据,但是现在的数据是默认值,
没有意义,应该等着数据的产生,再消费
2.如果生产者先抢到CPU的执行权,就回去产生数据,但是,它产生完数据后,还继续拥有执行权,
它又继续产生数据,这是有问题的,应该等着消费者把数据消费掉,然后再生产。
正常思路:
A:生产者
先看是否有数据,有就等待,没有就生产,生产完之后通知消费者来消费数据
B:消费者
先看是否有数据,有就消费,没有就等待,通知生产者生产数据
为了处理这样的问题,Java就提供了一种机制,等待唤醒机制
生产者与消费者的示例
public class GetThread implements Runnable { private Student s; public GetThread(Student s) { this.s = s; } @Override public void run() { while (true) { s.get(); } } } public class SetThread implements Runnable { private Student s; private int x = 0; public SetThread(Student s) { this.s = s; } @Override public void run() { while (true) { if (x % 2 == 0) { s.set("老大", 20); } else { s.set("小弟", 30); } x++; } } } public class Student { private String name; private int age; private boolean flag; // 默认情况是没有数据,如果是true,说明有数据 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(); } } /* 分析: 资源类:Student 设置学生数据:SetThread(生产者) 获取学生数据:GetThread(消费者) 测试类:StudentDemo 问题1:为了数据的效果好一些,我加入了循环和判断,给出不同的值,这个时候产生了新的问题 A:同一个数据出现多次 B:姓名和年龄不匹配 原因: A:同一个数据出现多次 CPU的一点点时间片的执行权,就足够你执行很多次。 B:姓名和年龄不匹配 线程运行的随机性 线程安全问题: A:是否是多线程环境 是 B:是否有共享数据 是 C:是否有多条语句操作共享数据 是 解决方案: 加锁。 注意: A:不同种类的线程都要加锁。 B:不同种类的线程加的锁必须是同一把。 问题2:虽然数据安全了,但是呢,一次一大片不好看,我就想依次的一次一个输出。 如何实现呢? 通过Java提供的等待唤醒机制解决。 等待唤醒: Object类中提供了三个方法: wait():等待 notify():唤醒单个线程 notifyAll():唤醒所有线程 为什么这些方法不定义在Thread类中呢? 这些方法的调用必须通过锁对象调用,而我们刚才使用的锁对象是任意锁对象。 所以,这些方法必须定义在Object类中。 */ public class StudentDemo { public static void main(String[] args) { //创建资源 Student s = new Student(); //设置和获取的类 SetThread st = new SetThread(s); GetThread gt = new GetThread(s); //线程类 Thread t1 = new Thread(st); Thread t2 = new Thread(gt); //启动线程 t1.start(); t2.start(); } }
八、线程组
Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
默认情况下所有的线程都属于主线程组
public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组
Thread(ThreadGroup group, Runnable target, String name)
如何修改线程所在的组呢?
创建一个线程组
创建其他线程的时候,把其他线程的组指定为我们自己新建线程组
九、线程池
1.程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。
而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。
线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。
在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池。
JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
public static ExecutorService newCachedThreadPool():创建一个具有缓存功能的线程池
public static ExecutorService newFixedThreadPool(int nThreads):创建一个可重用的,具有固定线程数的线程池
public static ExecutorService newSingleThreadExecutor():创建一个只有单线程的线程池,相当于上个方法的参数是1
这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
Future<?> submit(Runnable task)
<T> Future<T> submit(Callable<T> task)
2.如何实现线程池的代码呢?
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 MyRunnable implements Runnable { @Override public void run() { for (int x = 0; x < 100; x++) { System.out.println(Thread.currentThread().getName() + ":" + x); } } } public class ExecutorsDemo { public static void main(String[] args) { // 创建一个线程池对象,控制要创建几个线程对象。 ExecutorService pool = Executors.newFixedThreadPool(2); // 可以执行Runnable对象或者Callable对象代表的线程 pool.submit(new MyRunnable()); pool.submit(new MyRunnable()); //结束线程池 pool.shutdown(); } } 3.多线程的第三种实现方式 A:创建一个线程池对象,控制要创建几个线程对象。 public static ExecutorService newFixedThreadPool(int nThreads) B:这种线程池的线程可以执行: 可以执行Runnable对象或者Callable对象代表的线程 做一个类实现Runnable接口。 C:调用如下方法即可 <T> Future<T> submit(Callable<T> task) D:我就要结束,可以吗? 可以。 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(); } } //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; } } //第三种方式实现求和案例 public class MyCallable implements Callable<Integer> { private int number; public MyCallable(int number) { this.number = number; } @Override public Integer call() throws Exception { int sum = 0; for (int x = 1; x <= number; x++) { sum += x; } return sum; } } public class CallableDemo { public static void main(String[] args) throws InterruptedException, ExecutionException { // 创建线程池对象 ExecutorService pool = Executors.newFixedThreadPool(2); // 可以执行Runnable对象或者Callable对象代表的线程 Future<Integer> f1 = pool.submit(new MyCallable(100)); Future<Integer> f2 = pool.submit(new MyCallable(200)); // V get() Integer i1 = f1.get(); Integer i2 = f2.get(); System.out.println(i1); System.out.println(i2); // 结束 pool.shutdown(); } }
十、匿名内部类方式使用多线程
匿名内部类的格式:
new 类名或者接口名() {
重写方法;
};
本质:是该类或者接口的子类对象。
new Thread(){
代码…
}.start();
new Thread(new Runnable(){
代码…
}).start();
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(); // 更有难度的 //如果有两个run方法都实现了,那么运行的是Thread类的 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(); } }十一、定时器类
定时器是一个应用十分广泛的线程工具,可用于调度多个定时任务以后台线程的方式执行。
在Java中,可以通过Timer和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 abstract void run():此计时器任务要执行的操作。
public boolean cancel():取消此计时器任务。
开发中
Quartz是一个完全由java编写的开源调度框架。
public class TimerDemo2 { public static void main(String[] args) { // 创建定时器对象 Timer t = new Timer(); // 3秒后执行爆炸任务第一次,如果不成功,每隔2秒再继续炸 t.schedule(new MyTask(), 3000, 2000); } } // 做一个任务 class MyTask extends TimerTask { @Override public void run() { System.out.println("beng,爆炸了"); } } //需求:在指定的时间删除我们的指定目录 class DeleteFolder extends TimerTask { @Override public void run() { File srcFolder = new File("demo"); deleteFolder(srcFolder); } // 递归删除目录 public void deleteFolder(File srcFolder) { File[] fileArray = srcFolder.listFiles(); if (fileArray != null) { for (File file : fileArray) { if (file.isDirectory()) { deleteFolder(file); } else { System.out.println(file.getName() + ":" + file.delete()); } } System.out.println(srcFolder.getName() + ":" + srcFolder.delete()); } } } public class TimerTest { public static void main(String[] args) throws ParseException { Timer t = new Timer(); String s = "2016-3-3 15:00:00"; SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date d = sdf.parse(s); t.schedule(new DeleteFolder(), d); } }
十二、设计模式之单例设计模式
单例设计思想
保证类在内存中只有一个对象
如何实现类在内存中只有一个对象呢?
构造私有
本身提供一个对象
通过公共的方法让外界访问
单例模式:
饿汉式:类一加载就创建对象
懒汉式:用的时候,才去创建对象
面试题:单例模式的思想是什么?请写一个代码体现。
开发:饿汉式(是不会出问题的单例模式)
面试:懒汉式(可能会出问题的单例模式)
A:懒加载(延迟加载)
B:线程安全问题
a:是否多线程环境
是
b:是否有共享数据
是
c:是否有多条语句操作共享数据
是
解决方式:同步函数
//饿汉式 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 = Student.getStudent(); Student s2 = Student.getStudent(); System.out.println(s1 == s2); System.out.println(s1); System.out.println(s2); } } //懒汉式 public class Teacher { private Teacher() { } private static Teacher t = null; public synchronized static Teacher getTeacher() { if (t == null) { t = new Teacher(); } return t; } } public class TeacherDemo { public static void main(String[] args) { Teacher t1 = Teacher.getTeacher(); Teacher t2 = Teacher.getTeacher(); System.out.println(t1 == t2); System.out.println(t1); System.out.println(t2); } } 在Java中提供了一个单例类就是Runtime类 Runtime :每个 Java 应用程序都有一个 Runtime 类实例,使应用程序能够与其运行的环境相连接。 exec(String command):这个方法可以调用dos命令 public class RuntimeDemo { public static void main(String[] args) throws IOException { Runtime r = Runtime.getRuntime(); r.exec("winmine"); } }
十三、多线程中常见的面试题
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:线程的生命周期图
新建 -- 就绪 -- 运行 -- 死亡
新建 -- 就绪 -- 运行 -- 阻塞 -- 就绪 -- 运行 -- 死亡
相关文章推荐
- java写入文件(文件内容末尾追加)
- Spring mvc 跳转
- Exception in thread java.lang.IllegalThreadStateException
- Spring MVC URL路径映射
- java.io.Serializable浅析
- java web基础 (path,class_path,java_home)
- Maven Profile标签
- spring MVC +freemarker + easyui 实现sql查询和执行小工具总结
- Spring MVC的注解@
- Java基础之多线程
- eclipse jee配置struts2
- spring读取配置文件
- java中的坑(一)
- 在Eclipse中配置Struts2
- java调用第三方支付接口
- 2016蓝桥杯假期任务之《剪格子》
- 三大框架开发时,spring配置文件出现org.springframework.transaction.interceptor.TransactionInterceptor.invoke异常
- Java基础知识之IO流(二)
- Myeclipse 配置struts2实例
- MyEclipse快速入门