代码

注意：当方法区内的常量池有该字符串，以后再使用也就是调用该方法区内的该字符串（实际上），构造方法创建的字符串对象和直接赋值方式创建的字符串对象本质上是调用方式的不同（所以地址值有区别）

package MyString;
/*
       构造方法创造的字符串对象和直接赋值方式创建的字符串对象有什么区别？
            猜想：存放字符串的地址值不同，方便程度不同

         结果：构造方法创建的字符串对象是在堆内存
              直接赋值方式创建的对象是在方法区的常量池。

             字符串的内容是存储在方法区的常量池内的，为了方便字符串的重复利用

       扩充：  == 比较符号两边的数值
                 基本数据类型：比较的是基本数据类型的值是否相同（true/false）
                 引用数据类型：比较的是引用数据类型的地址值是否相同（true/false）
 */
public class StringDemo2 {
    public static void main(String[] args) {
        String s5="hello";
        //构造方法创造的字符串对象
        String s1=new String("hello");
        //直接赋值方式创建的字符串对象
        String s2="hello";
        //先看输出值
        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);

        String s3="hello";
        String s4=new String("hello");
        System.out.println("s1==s2? "+(s1==s2));//false
        System.out.println("s1==s3? "+(s1==s4));//false
        System.out.println("s2==s4? "+(s2==s3));//true
        System.out.println("s5==s1? "+(s5==s1));//false
        System.out.println("s5==s2? "+(s5==s2));//true
        System.out.println("s5==s3? "+(s5==s3));//true
        //其中如果构造方法创建的字符串对象在直接赋值后，则直接赋值会在常量池开辟一个新内存存放该字符串
        //往后再有直接赋值与该字符串相同的数据，则栈内存方法直接指向该方法区的常量池内的该字符串地址
        //而构造方法由于在堆内存开辟了新的空间，所以需要二次(多次)寻址才能调用该常量池内的字符串
        //由此来看，除去第一次开辟后，常量池内有该字符串，字符串的利用还是直接赋值创建对象更加方便省事
    }
}

图示

本文首发地址：https://www.dawnsite.cn/archives/256.html

一. 创建方式

1. 继承Thread类

• 定义Thread类的子类，并重写该类的run方法。
• 创建Thread子类的实例，即创建了线程对象。
• 调用线程对象的start()方法来启动线程。

package Thread;

/*
  1.继承Thread类
  2.重写run()方法
  3.调用start()方法开启线程
 */
public class TestThread extends Thread {
    @Override
    public void run() {
        //重写run()方法
        for (int i = 0; i < 10; i++) {
            System.out.println("小明在厨房做饭");
        }
    }

    public static void main(String[] args) {
        //创建Thread子类的实例
        TestThread testThread = new TestThread();
        //调用start()方法开启线程
        testThread.start();

        for (int i = 0; i < 200; i++) {
            System.out.println("小红在客厅打王者");
        }
    }
}

当多线程没有开启时，代码只执行主线程里面main()方法的代码，当开启线程后，经过cpu调度后开始执行（线程开启后不一定立即执行）

运行结果：

2. 实现Runnable接口

• 实现Runnable接口，并重写该接口的run()方法。
• 创建Runnable实现类的实例，并用该实例作为Thread的target来创建Thread对象，Thread对象才是真正的线程对象。
• 调用线程对象的start()方法来启动线程。

package Thread;

/*
  1.实现Runnable接口
  2.重写run()方法
  3.创建Runnable接口实现类实例，并将该实例放入Thread的target来创建Thread对象
  4.调用start()方法开启线程
 */
public class TestRunnable implements Runnable {
    @Override
    public void run() {
        //重写run()方法
        for (int i = 0; i < 10; i++) {
            System.out.println("小明在厨房做饭");
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口实现类实例
        TestRunnable testRunnable = new TestRunnable();
        //该实例放入Thread的target来创建Thread对象
        //调用start()方法开启线程
//        Thread thread = new Thread(testRunnable);
//        thread.start();
        new Thread(testRunnable).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("小红在客厅打王者");
        }
    }
}

执行结果：

3. 实现Callable接口

• 实现Callable接口并指定返回值，然后实现call()方法。
• 创建Callable实现类的实例，使用FutureTask包装类来包装Callable对象。
• 使用FutureTask对象作为Thread对象的target创建并启动新线程。
• 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

package Thread;

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

/*
  1.实现Callable接口。
  2.重写call()方法。
  3.创建Callable接口实现类实例，使用FutureTask包装类来包装Callable实例对象。
  4.使用FutureTask对象作为Thread的target来创建Thread对象。
  5.调用start()方法开启线程。
  6.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
 */
public class TestCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        //重写call()方法
        for (int i = 0; i < 10; i++) {
            System.out.println("小明在厨房做饭");
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable接口实现类实例
        TestCallable testCallable = new TestCallable();
        //使用FutureTask包装类来包装Callable实例对象
        FutureTask<Boolean> task = new FutureTask<>(testCallable);
        //使用FutureTask对象作为Thread的target来创建Thread对象
        //调用start()方法开启线程
        new Thread(task).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("小红在客厅打王者");
        }
        //调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
        System.out.println(task.get());  //获取call()的返回值。若调用时call()方法未返回，则会阻塞线程等待返回值
    }
}

执行结果：

二. 创建线程三种方式的优缺点

1. 继承Thread类

• 优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this即可。

• 缺点：java是单继承的，故无法再继承其他类。

2. 实现Runnable接口

• 优点：线程类只是实现了Runnable接口，还可以继承其他类。这种情况下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将cpu代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

• 缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

3. Runnable和Callable的区别

• Runnable规定的方法是run()，Callable规定的是call()。

• Runnable的任务执行后无返回值，Callable的任务执行后有返回值。

• call()方法可以抛出异常，run()方法不可以，因为run()方法本身没有抛出异常，所以自定义的线程类在重写run()方法的时候也无法抛出异常。

• 运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消人物的执行，还可获取执行结果。

4. start()和run()的区别

• start()方法用来，开启线程，但是线程开启后并没有立即执行，他需要获取cpu的执行权才可以执行。

• run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）。

任务执行情况，可取消人物的执行，还可获取执行结果。

4. start()和run()的区别

• start()方法用来，开启线程，但是线程开启后并没有立即执行，他需要获取cpu的执行权才可以执行。

• run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）。