Java多线程操作

同步与互斥

在 Java 中实现多线程有两种手段，一种是继承 Thread 类，另一种就是实现 Runnable 接口。下面我们就分别来介绍这两种方式的使用。

方式一：继承Thread类

public static void main(String[] args) {
    Mythread my1 = new Mythread("线程A");
    Mythread my2 = new Mythread("线程B");
    my1.start();
    my2.start();
}
public static class Mythread extends Thread{
    private String name;
    public Mythread(String name){
        this.name=name;
    }
    @Override
    public void run() {
        for(int i=1;i<=10;i++){
            System.out.println(name+"运行，i="+i);
        }
    }
}

方式二：实现Runnable接口

public static void main(String[] args) {
    MyThread my1 =new MyThread("线程A");
    MyThread my2 = new MyThread("线程B");
    Thread t1 = new Thread(my1);//实例化Thread类对象
    Thread t2 = new Thread(my2);
    t1.start();
    t2.start();
}
static class MyThread implements Runnable{
    private String name;
    public MyThread(String name){
        this.name=name;
    }
    @Override
    public void run() {
        for(int i=1;i<=10;i++){
            System.out.println(name+"运行，i="+i);
        }
    }
}

同步

同步代码块：

 synchronized(同步对象)｛ 
  需要同步的代码 
 ｝

public static void main(String[] args) {
    MyThread my1 = new MyThread();
    Thread t1 = new Thread(my1);
    Thread t2 = new Thread(my1);
    Thread t3 = new Thread(my1);
    t1.start();
    t2.start();
    t3.start();
}
public static class MyThread implements Runnable{
    int tickets =5;
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            synchronized (this){
                if(tickets>0){
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("卖票：tickets="+tickets--);
                }
            }
        }
    }
}

除了可以将需要的代码设置成同步代码块外，也可以使用 synchronized 关键字将一个方法声明为同步方法。

synchronized 方法返回值 方法名称（参数列表）｛ 

｝

class MyThread implements Runnable{
    private int ticket = 5 ;    // 假设一共有5张票
    public void run(){
        for(int i=0;i<100;i++){
            this.sale() ;   // 调用同步方法
        }
    }
    public synchronized void sale(){    // 声明同步方法
        if(ticket>0){   // 还有票
            try{
                Thread.sleep(300) ; // 加入延迟
            }catch(InterruptedException e){
                e.printStackTrace() ;
            }
            System.out.println("卖票：ticket = " + ticket-- );
        }

    }
};
public class SyncDemo03{
    public static void main(String args[]){
        MyThread mt = new MyThread() ;  // 定义线程对象
        Thread t1 = new Thread(mt) ;    // 定义Thread对象
        Thread t2 = new Thread(mt) ;    // 定义Thread对象
        Thread t3 = new Thread(mt) ;    // 定义Thread对象
        t1.start() ;
        t2.start() ;
        t3.start() ;
    }
};

//在Windows下实现多线程并互斥，主线程休眠2秒，次线程休眠1秒;
public static void main(String[] args) {
    MyThread my1 = new MyThread("main");
    MyThread my2 = new MyThread("从线程");
    my1.start();
    my2.start();
}
public static class MyThread extends Thread{
    private String name;

    public MyThread(String name){
        this.name=name;
    }

    public void run(){
        //注意获取线程名称要用this.name
        //如果用Thread.currentThread().getName()，则拿到的是Thread-0
        //https://www.cnblogs.com/wxw7blog/p/7300546.html
        System.out.println(this.name);
        for(int i=1;i<=2;i++){
            synchronized (this){
                if(this.name=="main"){
                    try{
                        Thread.sleep(2000);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    System.out.println("主线程休息2秒");
                }else {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("从线程休息1秒");
                }
            }
        }
    }
}