多线程
一.多线程的创建方式
1）继承于Thread类
-
创建一个继承与Thread类的子类
-
重写Thread的run方法
-
创建Thread类子类对象
-
子类对象调用start()方法
例如：遍历100以内所有偶数
class FirstThread extends Thread{ @Override public void run() { for(int i=0;i<=100;i++){ if(i%2==0){ System.out.println(i); } } } } public class ThreadTest { public static void main(String[] args) { FirstThread p = new FirstThread(); p.start(); for(int i=0;i<=100;i++){ if(i%2==0){ System.out.println(i+"main()******"); } } } }Thread类的有关方法
-
void start(): 启动线程，并执行对象的run()方法
-
run(): 线程在被调度时执行的操作
-
String getName(): 返回线程的名称
-
void setName(String name):设置该线程名称
-
static Thread currentThread(): 返回当前线程。在Thread子类中就 是this，通常用于主线程和Runnable实现类
-
static void yield()：线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
-
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将 被阻塞，直到 join() 方法加入的 join 线程执行完为止，低优先级的线程也可以获得执行
-
static void sleep(long millis)：(指定时间:毫秒) ，令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后 重排队。 抛出InterruptedException异常
-
stop(): 强制线程生命期结束，不推荐使用
-
boolean isAlive()：返回boolean，判断线程是否还活着
创建Thread的匿名子类实现多线程
new Thread(){ @Override public void run() { for (int i = 0; i < 100; i++) { if(i%2!=0){ System.out.println(Thread.currentThread().getName()+":"+i); } } } }.start(); -
2）实现Runnable接口
-
创建Runnable接口的实现类
-
实现Runnable接口的抽象方法run()
-
创建实现类的对象
-
将此对象作为参数传递到Thread类的构造器中创建Thread类的对象
-
通过Thread类的对象调用start()方法
注意：实际上Thread也实现了Runnable接口，源码如下
public class Thread extends Object implements Runnable
例如：
class TwoThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
TwoThread p=new TwoThread();
Thread thread = new Thread(p);
thread.start();
}
}
3）注意点：
- 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
- run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU 调度决定。
- 想要启动多线程，必须调用start方法。
- 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上 的异常“IllegalThreadStateException”。
二.线程的同步
1. Synchronized
1）Synchronized的用法
-
同步代码块：
synchronized (对象){ // 需要被同步的代码； } -
synchronized还可以放在方法声明中，表示整个方法为同步方法。
public synchronized void show (String name){ …. }
2）Synchronized中的锁是什么
-
任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）
-
同步方法的锁：静态方法（类名.class）、非静态方法（this）
-
同步代码块：自己指定，很多时候也是指定为this或类名.class
注意:必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就 无法保证共享资源的安全
一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方 法共用同一把锁（this），同步代码块（指定需谨慎）
3)死锁问题
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃 自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于 阻塞状态，无法继续
解决方法：
-
专门的算法、原则
-
尽量减少同步资源的定义
-
尽量避免嵌套同步
4)单例设计模式之懒汉式（线程安全的）
public class ThreadTest4 {
private static ThreadTest4 stance =null;
private ThreadTest4(){
}
public static ThreadTest4 show(){
if(stance==null) {
synchronized (ThreadTest4.class) {
if (stance == null) {
stance = new ThreadTest4();
}
}
}
return stance;
}
}
2. Lock
1）Lock的说明
-
java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。
-
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和 内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以 显式加锁、释放锁。
2)Lock的使用格式
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码;
}
finally{
lock.unlock(); //手动关锁
}
}
}
三、线程的通信
1. wait()、notify()、notifyAll()
wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当 前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有 权后才能继续执行。
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
- 这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常
- 因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁， 因此这三个方法只能在Object类中声明
使用两个线程打印 1-100。线程1, 线程2 交替打印,实现代码：
class Communication implements Runnable {
int i = 1;
public void run() {
while (true) {
synchronized (this) {
notify();
if (i <= 100) {
System.out.println(Thread.currentThread().getName() +
":" + i++);
} else
break;
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
四、JDK5.0新增多线程的创建方式
1）实现Callable接口
①说明
与使用Runnable相比， Callable功能更强大些
-
相比run()方法，可以有返回值
-
方法可以抛出异常
-
支持泛型的返回值
-
需要借助FutureTask类，比如获取返回结果
②实现方式
- 创建实现Callable接口的实现类
- 实现call方法
- 将实现类的对象传递到FutureTask的构造器中
- 将FutreTask对象传递到Thread的构造器中实例化Thread对象
- 用Thread对象调用start（）方法
class ThreadNum1 implements Callable {
private int sum=0;
@Override
public Object call() throws Exception {
for (int i = 1; i <=100 ; i++) {
System.out.println(i);
sum+=i;
}
return sum;
}
}
public class CallableTest {
public static void main(String[] args) {
ThreadNum1 p= new ThreadNum1();
FutureTask c=new FutureTask(p);
new Thread(c).start();
try {
Object g=c.get(); //get()方法获取call()方法的返回值
System.out.println(g);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
③Future接口
-
可以对具体Runnable、Callable任务的执行结果进行取消、查询是 否完成、获取结果等。
-
FutureTask是Future接口的唯一的实现类
-
FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行
又可以作为Future得到Callable的返回值
2)使用线程池
①说明
-
背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。
-
思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。
可以避免频繁创建销毁、实现重复利用。类似生活中的公共交 通工具。
-
好处： 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止
- …
②ExecutorService 和 Executors
- ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command）执行任务/命令，没有返回值，一般用来执行 Runnable
- Future submit(Callable task)：执行任务，有返回值，一般又来执行 Callable
- void shutdown() ：关闭连接池
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运 行命令或者定期地执行。
③实现代码
class ThreadNum2 implements Callable {
@Override
public Object call() throws Exception {
for (int i = 0; i <=100; i++) {
if(i%2==0){
System.out.println(i);
}
}return null;
}
}
class ThreadNum3 implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 != 0) {
System.out.println(i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
//创建一定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//设置线程池属性,
ThreadPoolExecutor service2 = (ThreadPoolExecutor)service;
service2.setCorePoolSize(10);
ThreadNum2 p =new ThreadNum2();
ThreadNum3 c = new ThreadNum3();
service.submit(p);
service.execute(c);
service.shutdown(); //关闭线程池
}
}
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
