标签：void 异常 原因 通过 代码 使用 submit 开发 not
Thread类的有关方法
创建线程
方式一：通过继承Thread
// 1.创建一个继承于thread类的子类
// 2.重写Thread类的run()
// 3.创建Thread类的子类的对象
// 4.通过此对象调用start()
class MyThread extends Thread{
@Override
public void run(){
for(int i=0;i<100;i++){
if(i%2==0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String args[]){
MyThread t1 = new MyThread();
t1.start();
System.out.println("hello");
}
}
方式二：通过重写Runnable接口的run方法
/*
* 创建多线程的方式二：实现Runnable接口
* 1.创建一个实现了Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法:run()
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
* 5.通过Thread类的对象调用start()
* */
class MyThread implements Runnable{
@Override
public void run(){
for(int i=0;i<100;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadMethodTest {
public static void main(String args[]){
MyThread mythread = new MyThread();
Thread t1 = new Thread(mythread);
t1.start();
}
}
方式三：通过实现Callable接口
/*
1.call()方法可以有返回值
2.call()方法可以抛出异常，被外面的操作捕获，获取异常的信息
3.Callable是支持泛型的
*/
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
// 1.创建一个实现Callable的实现类
class NumThread implements Callable {
// 2.实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception{
int sum = 0;
for(int i=0;i<100;i++){
if(i%2 == 0){
System.out.println(i);
}
}
return sum;
}
}
public class ThreadcallableTest {
public static void main(String args[]){
// 3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
// 4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
// 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()方法
new Thread(futureTask).start();
try {
// 6.获取Callable()中call方法的返回值
// get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println(sum);
}catch(InterruptedException e){
e.printStackTrace();
}catch(ExecutionException e){
e.printStackTrace();
}
}
}
方式四：
/*
线程池
1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线程管理
corePoolSize:核心池的大小
maximumPoolSzie:最大线程数
keepAliveTime:线程没有任务时最多保持多长的时间后终止
*/
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
class NumberThread implements Runnable{
@Override
public void run(){
for(int i=0;i<100;i++){
if(i%2 == 0){
System.out.println(i);
}
}
}
}
public class ThreadPool {
public static void main(String args[]){
// 1.提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
// 设置线程池的属性
// ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//service1.setCorePoolSize();
// 2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread()); // 适合使用于Runnable
// service.submit(); // 适合使用于Callable
service.shutdown();
}
}
比较创建线程的两种方式
开发中：优先选择：实现RUnnable接口的方式
原因：1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况
联系：Thread实现了Runnable接口
相同点：两种方式都需要重写run()方法，将线程要执行的逻辑声明在run()中
在java中，通过同步机制，来解决线程的安全问题
方法一：同步代码块
好处及坏处
好处：同步的方式，解决了线程的安全问题。
坏处：操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。
语法
synchronized(同步监视器){
//需要被同步的代码
}
说明：（1）操作共享数据的代码，即为需要被同步的代码
（2）共享数据：多个线程共同操作的变量
（3）同步监视器：俗称：锁。任何一个类的对象，都可以充当锁
要求：多个线程必须要共用同一把锁
(4) 1)在实现Runnable接口创建多线程的方式中，可以考虑用this充当同步监视器
2)在继承Thread类创建多线程的方式中，慎用This充当同步监视器，可以考虑使用当前类充当同步监视器（即CurrentClass.class）
示例1（重写runnable方法）
-- 示例
class MyThread implements Runnable{
private int ticket = 100;
Object obj = new Object(); // 一定要保证所有线程，共用同一把锁
@Override
public void run(){
while(true){
synchronized(obj){ //obj可以用this替代，用不着重新创建一个对象
if(ticket>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ticket);
ticket--;
}
else{
break;
}
}
}
}
}
public class ThreadMethodTest {
public static void main(String args[]){
MyThread mythread = new MyThread(); -- 共用同一个对象
Thread t1 = new Thread(mythread);
Thread t2 = new Thread(mythread);
Thread t3 = new Thread(mythread);
t1.start();
t2.start();
t3.start();
}
}
示例2（继承Thread）
class MyThread extends Thread{
private int ticket = 100;
private static Object obj = new Object(); // 一定要保证所有线程，共用同一把锁
@Override
public void run(){
while(true){
synchronized(obj){ //obj可以用MyThread.class来替代，该对象唯一，MyThrea只会加载一次
if(ticket>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ticket);
ticket--;
}
else{
break;
}
}
}
}
}
public class ThreadTest {
public static void main(String args[]){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
System.out.println("hello");
}
}
方法二：方法声明为synchronized类型
说明
关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只是不需要显示的声明
2.（1）非静态的同步方法，同步监视器是：this
（2）静态的同步方法，同步监视器是：当前类本身(即CurrentClass.class)
示例1
class MyThread implements Runnable{
private int ticket = 100;
// Object obj = new Object(); // 一定要保证所有线程，共用同一把锁
@Override
public void run(){
while(true){
this.show();
}
}
public synchronized void show(){
// synchronized(obj){ //obj可以用this替代，用不着重新创建一个对象
if(ticket>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ticket);
ticket--;
}
else{
break;
}
//}
}
}
public class ThreadMethodTest {
public static void main(String args[]){
MyThread mythread = new MyThread(); -- 共用同一个对象
Thread t1 = new Thread(mythread);
Thread t2 = new Thread(mythread);
Thread t3 = new Thread(mythread);
t1.start();
t2.start();
t3.start();
}
}
示例二
class MyThread extends Thread{
private int ticket = 100;
// private static Object obj = new Object(); // 一定要保证所有线程，共用同一把锁
@Override
public void run(){
while(true){
//synchronized(obj){ //obj可以用MyThread.class来替代，该对象唯一，MyThrea只会加载一次
this.show();
//}
}
}
public static synchronized void show(){ //使用了Mythread.class来保证监视器的唯一
if(ticket>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ticket);
ticket--;
}
else{
break;
}
}
}
public class ThreadTest {
public static void main(String args[]){
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
System.out.println("hello");
}
}
示例
public class DemoTest{
}
// 方式一：效率比较差，每个线程都需要在初始化时进行一次判断，进行抢锁
class Demo{
private Demo(){
}
private static Demo instance = null;
public static synchronized Demo getInstance(){
if(instance==null){
instance = Demo Bank();
}
return instance;
}
}
//方式二：效率稍高,每次初始化调用时，都会进行判断，如果已经不是null值，就不进行抢锁的行为，而是直接返回其值，否则，再去抢锁初始化instance
class Demo{
private Demo(){}
private static Demo instance = null;
public static Demo getInstance(){
if(instance==null){
synchronized(Demo.class){
if(instance==null){
instance = new Demo();
}
}
}
return instance;
}
}
说明
Synchronized与lock的异同？
- 相同点：二者都可以解决线程安全问题
- 不同点：（1）Synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
（2）Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
示例
import java.util.concurrent.locks.ReentrantLock;
class Demo implements Runnable{
private int ticket = 100;
// 1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run(){
while(True){
try{
lock.lock(); // 2.调用锁定的方法lock()
if(ticket>0){
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+ticket);
ticket--;
}else{
break; // 3.调用解锁方法:unlock()
}
}finally{
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String args[]){
Demo mydemo= new Demo(); -- 共用同一个对象
Thread t1 = new Thread(mydemo);
Thread t2 = new Thread(mydemo);
Thread t3 = new Thread(mydemo);
t1.start();
t2.start();
t3.start();
}
}
说明
涉及到的三个方法：
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait,就唤醒优先级最高的
notifyall():一旦执行此方法，就会唤醒所有被wait的线程
注意点：
（1）wait()、notify()、notifyALL()三个方法必须使用在同步代码块或同步方法中。
（2）wait()、notify()、notifyALL()三个方法的调用者必须是同步代码块或同步方法中的监视器（比如this或CurrentClass.class）
（3）wait()、notify()、notifyALL()三个方法是定义在java.lang.Object类中。
sleep()和wait()的异同？
- 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
- 不同点：（1）两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait()
（2）调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须在同步代码块或同步方法中
（3）关于是否释放同步监视器：如果两个方法都使用在同步代码快或同步方法中，sleep()不会释放锁，wait()会释放锁
说明
示例
/*
* 线程通行的应用
* 经典例题：生产者/消费者模型
*
* 分析
* 1.是否是多线程问题：是
* 2.是否有共享数据：是
* 3.如何解决线程的安全问题：同步机制，有三种方法
* 4.是否涉及线程的通信：是
*
* */
class Clerk{
// 1.申明一个元素，表示产品
private int productCount = 0;
public synchronized void productProduct(){ // 2.变成同步方法
if(productCount<20){
productCount++;
System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
notify(); // 4.释放锁，避免死锁
}else{
try{
wait(); // 3.等待线程完成
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
public synchronized void consumeProduct(){
if(productCount>0){
System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
productCount--;
notify();
}else{
try{
wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
class Producer extends Thread{
private Clerk clerk;
//1.创建一个构造器
public Producer(Clerk clerk){
this.clerk = clerk;
}
//2.重写run方法
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+":开始生产产品...");
while(true){
try{
//3.睡眠100毫秒
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
// 4.调用对象的生产方法
clerk.productProduct();
}
}
}
class Customer extends Thread{
private Clerk clerk;
public Customer(Clerk clerk){
this.clerk = clerk;
}
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+":开始消费产品...");
while(true){
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class ProductTest {
public static void main(String args[]){
// 1.声明一个clerk对象
Clerk clerk = new Clerk();
// 2.声明一个生产者
Producer p1 = new Producer(clerk);
// 3.设置线程名称
p1.setName("生产者1号");
// 4.声明一个消费者
Customer c1 = new Customer(clerk);
// 5.设置线程名称
c1.setName("消费者1号");
// 6.启动线程
p1.start();
c1.start();
}
}
标签：void 异常 原因 通过 代码 使用 submit 开发 not
原文地址：https://www.cnblogs.com/nuochengze/p/14762633.html
