Java マルチスレッド メカニズムの詳細については、こちらをご覧ください。

public class MyThread extends Thread { @Override public void run() { for (int i = 1; i " + i); } }}

public class TestThread { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); for (int i = 1; i "+i); } }}

public class TestThread { public static void main(String[] args) { MyThread t=new MyThread(); t.start(); //只能在继承Thread类的情况下用 System.out.println("线程id:"+t.getId()); System.out.println("线程名字:"+t.getName()); //调用Thread类的静态方法获取当前线程（这里获取的是主线程） System.out.println("线程id:"+Thread.currentThread().getId()); System.out.println("线程名字:"+Thread.currentThread().getName()); }}

public class MyThread extends Thread{ public MyThread() {}//无参构造器 public MyThread(String name) { super(name); } public void run() { for(int i=1;i
public class TestThread { public static void main(String[] args) { MyThread t1=new MyThread("子线程1");//通过构造方法 MyThread t2=new MyThread(); t2.setName("子线程2"); System.out.println("线程t1的id："+t1.getId()+" 名称："+t1.getName()); System.out.println("线程t2的id："+t2.getId()+" 名称："+t2.getName()); }}
        

         ログイン後にコピー
        
       

public class MyRunnable implements Runnable{//实现接口 @Override public void run() {//实现run方法 // TODO Auto-generated method stub for(int i=1;i
测试类
public class TestRunnable { public static void main(String[] args) { //1.创建MyRunnable对象，表示线程执行的功能 Runnable runnable=new MyRunnable(); //2.创建线程对象 Thread th=new Thread(runnable); //3.启动线程 th.start(); for(int i=1;i
使用匿名内部类
如果一个线程方法我们只使用一次，那么就不必设置一个单独的类，就可以使用匿名内部类实现该功能
public class TestRunnable { public static void main(String[] args) { Runnable runnable=new Runnable() { @Override public void run() { // TODO Auto-generated method stub for(int i=1;i
2.3 实现Callable接口
Callable和Thread、Runnable比较
 
对比继承Thread类和实现Runnable接口创建线程的方式发现，都需要有一个run()方法，但是这个run()方法有不足：
 
 
没有返回值
 
不能抛出异常
 
 
基于上面的两个不足，在JDK1.5以后出现了第三种创建线程的方式：实现Callable接口
 
实现Callable接口的好处：
 
 
有返回值
 
能抛出异常
 
 
缺点：
 
创建线程比较麻烦
 
 
1.实现Callable接口，可以不带泛型，如果不带泛型，那么call方法的返回值就是Object类型
 
2.如果带泛型，那么call的返回值就是泛型对应的类型
 
3.从call方法看到：方法有返回值，可以抛出异常
 
具体实现
实现接口
import java.util.Random;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;public class TestCallable implements Callable{ @Override public Integer call() throws Exception { // TODO Auto-generated method stub return new Random().nextInt(10); }}
        

         ログイン後にコピー
        
       

import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;public class Test { public static void main(String[] args) throws InterruptedException, ExecutionException { TestCallable tc=new TestCallable(); FutureTask ft=new FutureTask(tc); //创建线程对象 Thread th=new Thread(ft); th.start(); //获取线程得到的返回值 Integer In=ft.get(); System.out.println(In); }}

public class SleepThread extends Thread{ @Override public void run() { for (int i = 1; i 
PS：sleep()的异常在run方法中是不能抛出的，只能用try–catch处理
测试类
public class Test01 { public static void main(String[] args) { SleepThread sleepThread = new SleepThread(); sleepThread.start(); }}
        

         ログイン後にコピー
        
       

public class YieldThread extends Thread{ @Override public void run() { for (int i=1;i
测试类
public class Test01 { public static void main(String[] args) { YieldThread yieldThread01 = new YieldThread(); YieldThread yieldThread02 = new YieldThread(); yieldThread01.start(); yieldThread02.start(); }}
        

         ログイン後にコピー
        
       

public class JoinThread extends Thread{ @Override public void run() { for (int i=1;i
测试类
public class Test01 { public static void main(String[] args) throws InterruptedException { for (int i=1;i
结果：当主线程打印到5的时候，这时候子线程加入进来，就先执行完子线程，在执行主线程
4.4 守护线程（setDaemon）
将子线程设置为主线程的伴随线程，主线程停止的时候，子线程也不要继续执行了
 注意：先设置，在启动
子线程
public class TestThread extends Thread{ @Override public void run() { for(int i=1;i
测试类
public class Test01 { public static void main(String[] args) throws InterruptedException { TestThread daemonThread = new TestThread(); daemonThread.setDaemon(true);//设置守护线程 daemonThread.start(); for (int i=1;i
结果：当主线程结束时，子线程也跟着结束，并不会继续执行下去打印输出
4.5 线程优先级（setPriority）
线程优先级为1-10，默认为5，优先级越高，表示获取CPU机会越多
子线程
public class TestThread extends Thread{ @Override public void run() { for(int i=1;i
测试
public class Test01 { public static void main(String[] args) throws InterruptedException { TestThread th1 = new TestThread(); TestThread th2 = new TestThread(); TestThread th3 = new TestThread(); th1.setPriority(10);//设置线程1优先级10 th1.start(); th2.start();//线程2优先级默认不变，为5 th3.setPriority(1);//设置线程3优先级为1 th3.start(); }}
        

         ログイン後にコピー
        
       

public class BuyTicketRunnable implements Runnable{ private int ticketNum=10; @Override public void run() { for(int i=1;i
测试方法
public class BuyTicketTest { public static void main(String[] args) { // TODO Auto-generated method stub Runnable runnable=new BuyTicketRunnable(); Thread th1=new Thread(runnable,"窗口1"); Thread th2=new Thread(runnable,"窗口2"); Thread th3=new Thread(runnable,"窗口3"); th1.start(); th2.start(); th3.start(); }}
        

         ログイン後にコピー
        
       

public class BuyTicketRunnable implements Runnable{ static Object obj=new Object(); private int ticketNum=10; @Override public void run() { for(int i=1;i
 
多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块，其他线程无法访问其中的任何一个代码块
 
多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的所有代码块， 但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块
 
5.3 同步方法
 
synchronized（同步方法）
 
 
不要将run()定义为同步方法
 
非静态同步方法的同步监视器是this；静态同步方法（static）的同步监视器是 类名.class 字节码信息对象
 
同步代码块的效率要高于同步方法（原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是却是方法的内部）
 
同步方法的锁是this，一旦锁住一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住使用其他监视器的代码块
 
 
买票案例改进
public class BuyTicketRunnable implements Runnable{ private int ticketNum=10; @Override public void run() { for(int i=1;i0) { System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票！"); ticketNum--; } }}
        

         ログイン後にコピー
        
       

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class BuyTicketRunnable implements Runnable{ private int ticketNum=10; Lock lock=new ReentrantLock();//接口=实现类 可以使用不同的实现类 @Override public void run() { for(int i=1;i0) { System.out.println("在"+Thread.currentThread().getName()+"买到了第"+ticketNum+"张票！"); ticketNum--; } }catch(Exception e) { e.printStackTrace(); }finally { //关闭锁：--->即使有异常，这个锁也可以得到释放 lock.unlock(); } } }}

package 多线程;class Eat{ //代表两个筷子 public static Object o1=new Object(); public static Object o2=new Object(); public static void eat() { System.out.println("可以吃饭了"); }}class BoyThread extends Thread{ public void run() { synchronized (Eat.o1) { System.out.println("男孩拿到了第一根筷子！"); synchronized (Eat.o2) { System.out.println("男孩拿到了第二根筷子！"); Eat.eat(); } } }}class GirlThread extends Thread{ public void run() { synchronized (Eat.o2) { System.out.println("女孩拿到了第二根筷子！"); synchronized (Eat.o1) { System.out.println("女孩拿到了第一根筷子！"); Eat.eat(); } } }}public class MyLock { public static void main(String[] args) { BoyThread boy=new BoyThread(); GirlThread girl=new GirlThread(); boy.start(); girl.start(); }}

public class MyLock { public static void main(String[] args) { BoyThread boy=new BoyThread(); GirlThread girl=new GirlThread(); boy.start(); try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } girl.start(); }}

public class Product {//商品类 private String name;//名字 private String brand;//品牌 boolean flag = false;//设置标记，false表示商品没有，等待生产者生产 public synchronized void setProduct(String name, String brand) {//生产商品，同步方法，锁住的是this if (flag == true) {//如果flag为true，代表有商品，不生产，等待消费者消费 try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //生产商品 this.setName(name); this.setBrand(brand); System.out.println("生产者生产了" +this.getBrand() +this.getName()); //生产完，设置标志 flag = true; //唤醒消费线程 notify(); } public synchronized void getProduct() { if (flag == false) {//如果是false，则没有商品，等待生产者生产 try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //如果有商品，消费 System.out.println("消费者消费了" + this.getBrand() +this.getName()); //设置标志 flag = false; //唤醒线程 notify(); } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setBrand(String brand) { this.brand = brand; } public String getBrand() { return brand; }}

public class ProducterThread extends Thread {//生产者线程 private Product p; public ProducterThread(Product p) { this.p = p; } @Override public void run() { for (int i = 1; i 
功能分解三：消费者线程
public class CustomerThread extends Thread {//消费者线程 private Product pro; public CustomerThread(Product pro) { this.pro = pro; } @Override public void run() { for (int i = 1; i 
功能分解四：测试类
public class Test { public static void main(String[] args) { Product p = new Product(); ProducterThread pth = new ProducterThread(p); CustomerThread cth = new CustomerThread(p); pth.start(); cth.start(); }}
        

         ログイン後にコピー