Java多线程基础

例子来源： Youtube-cave of programming

create thread

class Runner extends Thread { public void run() { } } Runner runner1 = new Runner(); runner1.start(); class Runner implements Runnable { @Override public void run() { } } Thead t1 = new Thread(new Runner()); t1.start(); Thread t1 = new Thread(new Runnable() { @Override public void run() { } });

volatile keyword

The value of the variable will never be cached-locally: all reads and writes will go straight to “main memory”;Access to the variable acts as though it is enclosed in a synchronized block, sychronized on itself. Reads and writes are atomic for this variable. class Processor extends Thread { // use volatile to prevent thread from caching the variable private volatile boolean running = true; public void run() { while(running) { System.out.println("Hello"); try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } public void shutdown() { running = false; } } public class test { public static void main(String[] args) { // TODO Auto-generated method stub Processor proc1 = new Processor(); proc1.start(); System.out.println("Press enter to stop:"); Scanner scanner = new Scanner(System.in); scanner.nextLine(); proc1.shutdown(); } }

synchronized method

When a thread invokes a synchronized method, it automatically acquires the intrinsic lock for that method’s object and release it when the method returns. - First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object. - Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.

public class synchronizedDemo { private int count = 0; //make a atomic method, lock the method, only one thread can call it at the same time //same threads will share the method public synchronized void increment() { count++; } public static void main(String[] args) { synchronizedDemo demo = new synchronizedDemo(); demo.doWork(); } public void doWork() { Thread t1 = new Thread(new Runnable(){ @Override public void run() { for(int i=0; i < 10000; i++) { increment(); } } }); Thread t2 = new Thread(new Runnable(){ @Override public void run() { for(int i=0; i < 10000; i++) { increment(); } } }); t1.start(); t2.start(); try { //wait thread to die t1.join(); t2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Count:" + count); } }

synchronized block

The update to list1 and list2 can happen simultaneously.

import java.util.ArrayList; import java.util.List; import java.util.Random; public class Worker { private Object lock1 = new Object(); private Object lock2 = new Object(); private Random random = new Random(); private List<Integer> list1 = new ArrayList<Integer>(); private List<Integer> list2 = new ArrayList<Integer>(); public void stageOne() { synchronized(lock1){ try { Thread.sleep(1); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } list1.add(random.nextInt(100)); } } public void stageTwo() { synchronized(lock2){ try { Thread.sleep(1); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } list2.add(random.nextInt(100)); } } public void process() { for(int i = 0; i < 1000 ; i++) { stageOne(); stageTwo(); } } public void main() { System.out.println("Starting ..."); long start = System.currentTimeMillis(); Thread t1 = new Thread(new Runnable() { @Override public void run() { process(); } }); Thread t2 = new Thread(new Runnable() { @Override public void run() { process(); } }); t1.start(); t2.start(); try { t1.join(); t2.join();; } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } long end = System.currentTimeMillis(); System.out.println("Running time: " + (end - start)); System.out.println("length of list1: "+ list1.size()); System.out.println("length of list2: "+ list2.size()); }; }

ThreadPool

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; class Processor implements Runnable { private int id; public Processor(int id) { this.id = id; } @Override public void run() { System.out.println("Starting: " + this.id); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Completed: "+ this.id); } } public class App { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(2); for(int i = 0; i < 5; i++) { executor.submit(new Processor(i)); } //do not accept more tasks executor.shutdown(); System.out.println("all tasks submitted."); try { //wait till all tasks are done executor.awaitTermination(1, TimeUnit.DAYS); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("All tasks completed."); } }