Callable

Future

get() Future

ThreadPoolDemo.java

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

public class ThreadPoolDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        
        //Callable
        //MyCallable c = new MyCallable();
        MyCallable c = new MyCallable(100, 200);
        MyCallable c2 = new MyCallable(10, 20);
        
        //Callablecall(), 
        //<Integer> Future<Integer> submit(Callable<Integer> task)
        // Future 
        Future<Integer> result = threadPool.submit(c);
        // Future  get 
        Integer sum = result.get();
        System.out.println("sum=" + sum);
        
        //
        result = threadPool.submit(c2);
        sum = result.get();
        System.out.println("sum=" + sum);
        //()
        
    }
}

MyCallable.java

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    //
    int x = 5;
    int y = 3;
    //
    public MyCallable(){
    }
    public MyCallable(int x, int y){
        this.x = x;
        this.y = y;
    }

    @Override
    public Integer call() throws Exception {
        return x+y;
    }
}

Java Thread run() start()

Java java.lang.Thread VM Thread Thread run() run() Thread start()

Java

• start
• start
• run
• ()sleep,suspendwait
• run stop start

• 1 Thread run start
• 2 Runnable run new Thread(Runnable target).start()

cpustart CPU run() CPU run()

start() CPU JVM Thread run() start run run start

• 1.start() run Thread start() Thread run() run() run CPU
• 2.run() run

CPU

public class Test {
    public static void main(String[] args) {
        Runner1 runner1 = new Runner1();
        Runner2 runner2 = new Runner2();
//        Thread(Runnable target)  Thread 
        Thread thread1 = new Thread(runner1);
        Thread thread2 = new Thread(runner2);
//        thread1.start();
//        thread2.start();
        thread1.run();
        thread2.run();
    }
}
 
class Runner1 implements Runnable { // Runnablejdk
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Runner1——————————" + i);
        }
    }
}
 
class Runner2 implements Runnable { // Runnablejdk
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Runner2==========" + i);
        }
    }
}

run synchronized {}

Public synchronized  {} 

Lock

Lock finally

Lock lock=new ReentranttLock()    // Reentrant

Lock synchronized JDK1.5

Lock :

void lock()   //  
void unlock() //  

Lock :

java.util.concurrent.locks.ReentrantLock implements Lock

:

• 1. ReentrantLock
• 2. Lock lock
• 3. Lock unlock

public class RunnableImpl implements Runnable{
    //
    private int ticket = 100;
    //1.ReentrantLock
    Lock l = new ReentrantLock();
    //:
    @Override
    public void run() {
        //,
        while(true){
            //2.,Locklock
            l.lock();
            //0
            if(ticket>0){
                //,10
                try {
                    //
                    Thread.sleep(10);
                    // ticket--
                    System.out.println(Thread.currentThread().getName()+""+ticket+"!");
                    ticket--;
                } catch (InterruptedException e) {
                    //
                    e.printStackTrace();
                }finally {
                    //,()
                    //3.,Lockunlock
                    l.unlock();//,,,
                }
            }
        }
    }
}

javaObject

notify() wait()

notifyAll()

wait()WAITING

wait()

wait(long) n

wait(long, int)