Thread
-
Thread类的有关方法
- void start():启动线程，并执行对象的run()方法
- run():线程在被调度时执行的操作
- Staring getName():返回线程的名称
- void setName(String name):设置该线程名称
- static Thread currentThread():返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
- yield():释放当前CPU的执行权
- join()： 在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
- stop():已过时，当执行此方法时，强制结束当前线程
- sleep(long millitime):让当前的线程休眠
-
创建线程
-
方式一：通过继承Thread
// 1.创建一个继承于thread类的子类 // 2.重写Thread类的run() // 3.创建Thread类的子类的对象 // 4.通过此对象调用start() class MyThread 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[]){ MyThread t1 = new MyThread(); t1.start(); System.out.println("hello"); } } -
方式二：通过重写Runnable接口的run方法
/* * 创建多线程的方式二：实现Runnable接口 * 1.创建一个实现了Runnable接口的类 * 2.实现类去实现Runnable中的抽象方法:run() * 3.创建实现类的对象 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象 * 5.通过Thread类的对象调用start() * */ class MyThread 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 ThreadMethodTest { public static void main(String args[]){ MyThread mythread = new MyThread(); Thread t1 = new Thread(mythread); t1.start(); } } -
方式三：通过实现Callable接口
/* 1.call()方法可以有返回值 2.call()方法可以抛出异常，被外面的操作捕获，获取异常的信息 3.Callable是支持泛型的 */ import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; // 1.创建一个实现Callable的实现类 class NumThread implements Callable { // 2.实现call方法,将此线程需要执行的操作声明在call()中 @Override public Object call() throws Exception{ int sum = 0; for(int i=0;i<100;i++){ if(i%2 == 0){ System.out.println(i); } } return sum; } } public class ThreadcallableTest { public static void main(String args[]){ // 3.创建Callable接口实现类的对象 NumThread numThread = new NumThread(); // 4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象 FutureTask futureTask = new FutureTask(numThread); // 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法 new Thread(futureTask).start(); try { // 6.获取Callable()中call方法的返回值 // get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值 Object sum = futureTask.get(); System.out.println(sum); }catch(InterruptedException e){ e.printStackTrace(); }catch(ExecutionException e){ e.printStackTrace(); } } } -
方式四：
/* 线程池 1.提高响应速度（减少了创建新线程的时间） 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建） 3.便于线程管理 corePoolSize:核心池的大小 maximumPoolSzie:最大线程数 keepAliveTime:线程没有任务时最多保持多长的时间后终止 */ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; class NumberThread 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[]){ // 1.提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); // 设置线程池的属性 // ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; //service1.setCorePoolSize(); // 2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象 service.execute(new NumberThread()); // 适合使用于Runnable // service.submit(); // 适合使用于Callable service.shutdown(); } }
-
-
比较创建线程的两种方式
开发中：优先选择：实现RUnnable接口的方式 原因：1.实现的方式没有类的单继承性的局限性 2.实现的方式更适合来处理多个线程有共享数据的情况 联系：Thread实现了Runnable接口 相同点：两种方式都需要重写run()方法，将线程要执行的逻辑声明在run()中
线程的生命周期
解决线程安全问题
-
在java中，通过同步机制，来解决线程的安全问题
-
方法一：同步代码块
-
好处及坏处
好处：同步的方式，解决了线程的安全问题。 坏处：操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 -
语法
synchronized(同步监视器){ //需要被同步的代码 } 说明：（1）操作共享数据的代码，即为需要被同步的代码 （2）共享数据：多个线程共同操作的变量 （3）同步监视器：俗称：锁。任何一个类的对象，都可以充当锁 要求：多个线程必须要共用同一把锁 (4) 1)在实现Runnable接口创建多线程的方式中，可以考虑用this充当同步监视器 2)在继承Thread类创建多线程的方式中，慎用This充当同步监视器，可以考虑使用当前类充当同步监视器（即CurrentClass.class） -
示例1（重写runnable方法）
-- 示例 class MyThread implements Runnable{ private int ticket = 100; Object obj = new Object(); // 一定要保证所有线程，共用同一把锁 @Override public void run(){ while(true){ synchronized(obj){ //obj可以用this替代，用不着重新创建一个对象 if(ticket>0){ try{ Thread.sleep(100); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+ticket); ticket--; } else{ break; } } } } } public class ThreadMethodTest { public static void main(String args[]){ MyThread mythread = new MyThread(); -- 共用同一个对象 Thread t1 = new Thread(mythread); Thread t2 = new Thread(mythread); Thread t3 = new Thread(mythread); t1.start(); t2.start(); t3.start(); } } -
示例2（继承Thread）
class MyThread extends Thread{ private int ticket = 100; private static Object obj = new Object(); // 一定要保证所有线程，共用同一把锁 @Override public void run(){ while(true){ synchronized(obj){ //obj可以用MyThread.class来替代，该对象唯一，MyThrea只会加载一次 if(ticket>0){ try{ Thread.sleep(100); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+ticket); ticket--; } else{ break; } } } } } public class ThreadTest { public static void main(String args[]){ MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); MyThread t3 = new MyThread(); t1.start(); t2.start(); t3.start(); System.out.println("hello"); } }
-
-
方法二：方法声明为synchronized类型
-
说明
关于同步方法的总结： 1.同步方法仍然涉及到同步监视器，只是不需要显示的声明 2.（1）非静态的同步方法，同步监视器是：this （2）静态的同步方法，同步监视器是：当前类本身(即CurrentClass.class) -
示例1
class MyThread implements Runnable{ private int ticket = 100; // Object obj = new Object(); // 一定要保证所有线程，共用同一把锁 @Override public void run(){ while(true){ this.show(); } } public synchronized void show(){ // synchronized(obj){ //obj可以用this替代，用不着重新创建一个对象 if(ticket>0){ try{ Thread.sleep(100); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+ticket); ticket--; } else{ break; } //} } } public class ThreadMethodTest { public static void main(String args[]){ MyThread mythread = new MyThread(); -- 共用同一个对象 Thread t1 = new Thread(mythread); Thread t2 = new Thread(mythread); Thread t3 = new Thread(mythread); t1.start(); t2.start(); t3.start(); } } -
示例二
class MyThread extends Thread{ private int ticket = 100; // private static Object obj = new Object(); // 一定要保证所有线程，共用同一把锁 @Override public void run(){ while(true){ //synchronized(obj){ //obj可以用MyThread.class来替代，该对象唯一，MyThrea只会加载一次 this.show(); //} } } public static synchronized void show(){ //使用了Mythread.class来保证监视器的唯一 if(ticket>0){ try{ Thread.sleep(100); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+ticket); ticket--; } else{ break; } } } public class ThreadTest { public static void main(String args[]){ MyThread t1 = new MyThread(); MyThread t2 = new MyThread(); MyThread t3 = new MyThread(); t1.start(); t2.start(); t3.start(); System.out.println("hello"); } }
-
-
线程安全的单例模式之懒汉式
-
示例
public class DemoTest{ } // 方式一：效率比较差，每个线程都需要在初始化时进行一次判断，进行抢锁 class Demo{ private Demo(){ } private static Demo instance = null; public static synchronized Demo getInstance(){ if(instance==null){ instance = Demo Bank(); } return instance; } } //方式二：效率稍高,每次初始化调用时，都会进行判断，如果已经不是null值，就不进行抢锁的行为，而是直接返回其值，否则，再去抢锁初始化instance class Demo{ private Demo(){} private static Demo instance = null; public static Demo getInstance(){ if(instance==null){ synchronized(Demo.class){ if(instance==null){ instance = new Demo(); } } } return instance; } }
线程的同步——同步锁
-
说明
Synchronized与lock的异同？ - 相同点：二者都可以解决线程安全问题 - 不同点：（1）Synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器 （2）Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()） -
示例
import java.util.concurrent.locks.ReentrantLock; class Demo implements Runnable{ private int ticket = 100; // 1.实例化ReentrantLock private ReentrantLock lock = new ReentrantLock(); @Override public void run(){ while(True){ try{ lock.lock(); // 2.调用锁定的方法lock() if(ticket>0){ try{ Thread.sleep(100); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+":"+ticket); ticket--; }else{ break; // 3.调用解锁方法:unlock() } }finally{ lock.unlock(); } } } } public class LockTest { public static void main(String args[]){ Demo mydemo= new Demo(); -- 共用同一个对象 Thread t1 = new Thread(mydemo); Thread t2 = new Thread(mydemo); Thread t3 = new Thread(mydemo); t1.start(); t2.start(); t3.start(); } }
线程的通信
-
说明
涉及到的三个方法： wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器 notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait,就唤醒优先级最高的 notifyall():一旦执行此方法，就会唤醒所有被wait的线程 注意点： （1）wait()、notify()、notifyALL()三个方法必须使用在同步代码块或同步方法中。 （2）wait()、notify()、notifyALL()三个方法的调用者必须是同步代码块或同步方法中的监视器（比如this或CurrentClass.class） （3）wait()、notify()、notifyALL()三个方法是定义在java.lang.Object类中。 sleep()和wait()的异同？ - 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态 - 不同点：（1）两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait() （2）调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须在同步代码块或同步方法中 （3）关于是否释放同步监视器：如果两个方法都使用在同步代码快或同步方法中，sleep()不会释放锁，wait()会释放锁
消费者及生产者模型
-
说明
-
示例
/* * 线程通行的应用 * 经典例题：生产者/消费者模型 * * 分析 * 1.是否是多线程问题：是 * 2.是否有共享数据：是 * 3.如何解决线程的安全问题：同步机制，有三种方法 * 4.是否涉及线程的通信：是 * * */ class Clerk{ // 1.申明一个元素，表示产品 private int productCount = 0; public synchronized void productProduct(){ // 2.变成同步方法 if(productCount<20){ productCount++; System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品"); notify(); // 4.释放锁，避免死锁 }else{ try{ wait(); // 3.等待线程完成 }catch(InterruptedException e){ e.printStackTrace(); } } } public synchronized void consumeProduct(){ if(productCount>0){ System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品"); productCount--; notify(); }else{ try{ wait(); }catch(InterruptedException e){ e.printStackTrace(); } } } } class Producer extends Thread{ private Clerk clerk; //1.创建一个构造器 public Producer(Clerk clerk){ this.clerk = clerk; } //2.重写run方法 @Override public void run(){ System.out.println(Thread.currentThread().getName()+":开始生产产品..."); while(true){ try{ //3.睡眠100毫秒 Thread.sleep(100); }catch(InterruptedException e){ e.printStackTrace(); } // 4.调用对象的生产方法 clerk.productProduct(); } } } class Customer extends Thread{ private Clerk clerk; public Customer(Clerk clerk){ this.clerk = clerk; } @Override public void run(){ System.out.println(Thread.currentThread().getName()+":开始消费产品..."); while(true){ try{ Thread.sleep(1000); }catch(InterruptedException e){ e.printStackTrace(); } clerk.consumeProduct(); } } } public class ProductTest { public static void main(String args[]){ // 1.声明一个clerk对象 Clerk clerk = new Clerk(); // 2.声明一个生产者 Producer p1 = new Producer(clerk); // 3.设置线程名称 p1.setName("生产者1号"); // 4.声明一个消费者 Customer c1 = new Customer(clerk); // 5.设置线程名称 c1.setName("消费者1号"); // 6.启动线程 p1.start(); c1.start(); } }