java的Thread多线程

线程的三种创建方法

方法一：

public class ThraedDemo1 {
    public static void main(String[] args) {
//new一个新线程
        Thread t = new MyThread();
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }

    //定义一个线程类继承Thread类
    static class MyThread extends Thread {
        //    重写run方法，定义线程以后要干什么
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程执行输出" + i);
            }
        }
    }
}

 方法二：

 

 

package Thread;

public class ThreadDemo2 {
    public static void main(String[] args) {
//   创建一个任务对象
    MyRunnable target=new MyRunnable();
//    把任务对象交给Thread处理
        Thread t=new Thread(target);
        Thread t1=new Thread(target);
        t.start();
        t1.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出" + i);
        }
    }
}

//定义一个线程任务类，实现Runnable接口
class MyRunnable implements Runnable{
//    重写run方法，定义线程的执行任务
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出" + i);
        }
    }
}

前两种存在问题：

package Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThreadDemo3 {
    public static void main(String[] args) {
//创建一个Callable的任务对象
        Callable<String> call=new MyCallable(100);
// 把Callable任务对象交给FutureTask对象
//FutureTask对象作用1：是Runnable的对象，可以交给Thread。
//FutureTask对象作用2：可以在线程执行完毕后使用get方法得到线程执行完成的结果
        FutureTask<String> f1=new FutureTask<>(call);
        Thread t=new Thread(f1);
        t.start();

        try {
            String rs1= f1.get();
            System.out.println("第一个结果" + rs1);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n){
        this.n=n;
    }

    @Override
    public String call() throws Exception {
        int sum=0;
        for (int i = 0; i <=n; i++) {
            sum+=i;
        }

        return sum+"";
    }
}

 

线程锁

       线程锁synchronized的作用主要是为保证某些特定的情况下线程在运行时一个对象只能在一个线程内运行，不能同时两个线程都操作一个对象，例如银行账户操作。在锁对象的选取上，如果选的不合理就会造成一些无关对象受到牵连，所以在选对象是可以选用this代表当前对象。

同步代码块

实例方法代码

 

 静态方法代码

    静态方法以类名作为对象，所以在只要是一个类的对象使用一个线程其他的都会被锁，无法使用，不推荐使用静态方法。

 同步方法 同步方法代码

 

 lock锁

每个对象都有自己的lock锁，用final修饰不可被修改

 

 

 相比于synchronized 而言，lock更加灵活，没有利用对象，而是在每个对象在建立时就设定了lock这个变量，使得每个对象都有自己的lock，所以可以通过lock来锁定这个对象。

线程通信

代码演示

 

线程池