Thread pool, thread-safe

The concept: a container to accommodate multiple threads, which threads can be reused, eliminating the need for frequent create objects without having to repeatedly create threads and consume too many resources.

Thread pool thread is mainly used to solve the life-cycle cost and resource shortage.

Use the thread pool implement Runnable:

class MyRnu the implements the Runnable {public
　　public void RUN () { // Get the name of the current thread object 　　String name = Thread.currentThread () getName ();. 　　for (int I = 0; I <20 is; I ++) { 　　　　the System. Out.println (name + I); 　　　　the try { 　　　　　　the Thread.sleep (1000); 　　　　} the catch (InterruptedException E) { 　　　　　　e.printStackTrace (); 　　　　　　} 　　　　} 　　} }
　　

public static void main(String[] args) {
　　//用线程池的方式完成线程任务
　　//1.获取线程池对象
　　ExecutorService es=Executors.newFixedThreadPool(2);
　　//2.创建线程任务对象
　　MyRnu mr=new MyRnu();
　　//3.让线程池自主选一条线程执行线程任务
　　es.submit(mr);
　　//关闭线程池
　　//es.shutdown();
}

使用线程池的方式实现Callable接口：

Cllable接口：用来指定线程的任务。其中的call（）方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

public class MyCallable implements Callable<String>{
　　public String call() throws Exception {
　　　　return "abc";
　　}
}

public static void main(String[] args) throws InterruptedException, ExecutionException {
　　//从线程池工厂中获取线程池对象
　　ExecutorService es=Executors.newFixedThreadPool(2);
　　//创建线程任务对象
　　MyCallable mc=new MyCallable();
　　//让线程池自主选择一条线程执行线程任务
　　Future<String> f=es.submit(mc);
　　//获取线程任务的返回值
　　System.out.println(f.get());
}

package com.oracle.demo05;

import java.util.concurrent.Callable;

public class ZuoyeCall implements Callable<Integer>{
    private int num1;
    private int num2;
    public ZuoyeCall() {
    }
    public ZuoyeCall(int num1,int num2){
        this.num1=num1;
        this.num2=num2;
    }
    public Integer call() throws Exception {
        //求和
        int sum=0;
        for(int i=num1;i<=num2;i++){
            sum+=i;
        }
        return sum;
    }

}

package com.oracle.demo05;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Zuoyedemo {
    /*用线程池分别计算50..100的和
                    44..200的和*/
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //1.从线程池工厂获取线程对象
        ExecutorService es=Executors.newFixedThreadPool(2);
        //2.创建线程任务对象
        ZuoyeCall zc1=new ZuoyeCall(50,100);
        ZuoyeCall zc2=new ZuoyeCall(44,200);
        //3.从线程池自主选择线程执行任务
        Future<Integer> f1=es.submit(zc1);
        Future<Integer> f2=es.submit(zc2);
        //4.获取线程任务返回值
        int sum1=f1.get();
        int sum2=f2.get();
        System.out.println(sum1);
        System.out.println(sum2);
        //关闭线程
        es.shutdown();
    }
}

线程安全：

线程同步（线程安全处理Synchronized）

方式一：同步代码块

public class Tickets implements Runnable {
　　// 定义100张电影票
　　private int tickeet = 100;
　　// 定义同步锁
　　Object obj = new Object();

　　public void run() {
　　　　while (true) {
　　　　　　// 同步代码块将可能会产生线程安全问题的代码包括起来
　　　　　　synchronized (obj) {

　　　　　　if (tickeet > 0) {
　　　　　　　　try {
　　　　　　　　Thread.sleep(50);
　　　　　　　　} catch (InterruptedException e) {
　　　　　　　　// TODO Auto-generated catch block
　　　　　　　　e.printStackTrace();
　　　　　　　　}
　　　　　　　　System.out.println(Thread.currentThread().getName() + "出售第" + tickeet-- + "张票");
　　　　　　　　}
　　　　　　}
　　　　}
　　}
}

方式二：同步方法

public class Tickets2 implements Runnable {
　　// 定义100张电影票
　　private int tickeet = 100;
　　// 定义同步锁
　　Object obj = new Object();
　　public void run() {
　　　　while (true) {
　　　　　　method();
　　　　}
　　}

　　//定义同步方法
　　public synchronized void method(){
　　　　if (tickeet > 0) {
　　　　　　try {
　　　　　　　　Thread.sleep(50);
　　　　　　} catch (InterruptedException e) {
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　　　System.out.println(Thread.currentThread().getName() + "出售第" + tickeet-- + "张票");
　　　　}
　　}
}

同步方法中的锁对象是 this

静态同步方法中的锁对象是类名.class

Lock接口：

public class Tickets3 implements Runnable {
　　// 定义100张电影票
　　private int tickeet = 100;
　　// 创建锁接口对象
　　Lock lock = new ReentrantLock();
　　public void run() {
　　　　while (true) {
　　　　　　// 获取锁
　　　　　　lock.lock();
　　　　　　if (tickeet > 0) {
　　　　　　　　try {
　　　　　　　　　　Thread.sleep(50);
　　　　　　　　　　System.out.println(Thread.currentThread().getName() + "出售第" + tickeet-- + "张票");
　　　　　　　　} catch (InterruptedException e) {
　　　　　　　　　　e.printStackTrace();
　　　　　　　　} finally {
　　　　　　　　　　// 释放锁
　　　　　　　　　　lock.unlock();
　　　　　　　　}　　
　　　　　　}
　　　　}
　　}
}

Thread pool, thread-safe

Guess you like