java基础复习之多线程Thread 十三

最新推荐文章于 2023-06-25 21:09:34 发布
最新推荐文章于 2023-06-25 21:09:34 发布
阅读量437 收藏 1
点赞数 1
分类专栏： java SE javaSE 文章标签： Thread Runnable sleep wait
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/onceing/article/details/62042078
版权

 

多线程：就是应用程序多条执行路径
进程：正在运行的程序，

 

  线程： 进程的执行单元，一条执行路径

 

 

线程的简单使用方式一：

 

package thread;
/**
 * 
 * @author Angus
 *	getName() 返回该线程的名称。
 */
public class MyThread extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 30; i++) {
			
			System.out.println(getName()+"hello");
		}
	}
}


ThreadDemo测试;

 

 

 

 

package thread;
/**
 * @author Angus
 *	
 *	多线程：就是应用程序多条执行路径
 *		进程：正在运行的程序，
 *		线程： 进程的执行单元，一条执行路径
 *	
 *	实现？
 *		线程类Thread：
 *			A;定义一个类基础Thread类，重写run方法，start()方法启动线程。
 *			B:实现Runnable接口,重写run方法
 *	
 */
public class ThreadDemo{

	public static void main(String[] args) {
		MyThread mt = new MyThread();
		MyThread mt2 = new MyThread();
		mt.start();
//		mt.start(); //Exception in thread "main" java.lang.IllegalThreadStateException
//		//连续开始两次线程报错。。分析异常开启两个线程需要两个线程对象
		
		mt.setName("zzz");
		mt2.setName("ddd");
		mt2.start();
	}
	
	
}


线程的简单使用方式二;

 

 

package thread;
/**
 * 	
 * @author Angus
 *	B:实现Runnable接口,重写run方法
 */
public class MyRunnableDemo {

	public static void main(String[] args) {
		MyRunnable my = new MyRunnable();
		//数显runnable的发类没有start的方法，启动必须启动start方法
		//所以需要考虑Thread类
		Thread t = new Thread(my);
		Thread t2 = new Thread(my);
		
		t.setName("xxxx");
		t2.setName("wwww");
		t.start();
		t2.start();
	}

}


MyRunnable类：

 

 

package thread;

/**
 * @author Angus 实现Runnable接口,重写run方法 public static Thread currentThread()
 *         返回对当前正在执行的线程对象的引用。
 */
public class MyRunnable implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 30; i++) {

			System.out.println(Thread.currentThread().getName() + "  hello");
		}
	}

}

运行结果差不多。。。。
 

 

会发现第一种每次需要new两个对象，创建两个线程，走了两次run，第二种只创建了一个资源对象，这样数据和操作分离更好一些，一般开发中使用第二种多一些。。。

 

线程的生命周期：

 

多线程应用的场景：

运行都会卡死，建议DOS测试，这样可以关闭，eclipse只能关闭软件了。。。

方式一：

 

package thread2;
/**
 * 
 * @author Angus
 *	多线程应用的场景
 *		窗口卖票
 *	
 *	有一趟火车，票不多了，还有200张，四个窗口卖票
 *	
 *	使用多线程模拟卖票
 *		方式1 继承Thread类
 *		方式2实现Runnable接口
 *	
 */
public class ThreadTest {
	public static void main(String[] args) {
		TicketTread tt1 = new TicketTread();
		TicketTread tt2 = new TicketTread();
		TicketTread tt3 = new TicketTread();
		TicketTread tt4 = new TicketTread();
		
		tt1.setName("窗口1");
		tt2.setName("窗口2");
		tt3.setName("窗口3");
		tt4.setName("窗口4");
		
		tt1.start();
		tt2.start();
		tt3.start();
		tt4.start();
	}
	
}


TicketTread

package thread2;
/**
 * @author Angus
 *	方式一
 */
public class TicketTread extends Thread {
	@Override
	public void run() {
		int tickets = 200;
		
		while(true){
			if(tickets>0){
				System.out.println(getName()+" 正在出售"+(tickets--)+"张票");
			}
		}
	}
}


这样运行会CPU报表。。。直接死机，

 

原因： 每个线程new的时候都是一个新的200，都走run方法，，死循环。。

改进;

TicketTread

 

package thread2;
/**
 * @author Angus
 *	方式一
 */
public class TicketTread extends Thread {
	private static int tickets = 200;
	@Override
	public void run() {
		
		
		while(true){
			if(tickets>0){
				System.out.println(getName()+" 正在出售"+(tickets--)+"张票");
			}
		}
	}
}


而static修饰的成员变量比较占用资源，去掉更换第二种方式测试

 

 

package thread2;
/**
 * 
 * @author Angus
 *	方式二
 */
public class TicketRunnanble implements Runnable {
	private int tickets = 200;
	@Override
	public void run() {

		while(true){
			if(tickets>0){
				System.out.println(Thread.currentThread().getName()+" 正在出售"+(tickets--)+"张票");
			}
		}
	}

}


Runnable测试：

 

 

package thread2;
/**
 * 
 * @author Angus
 *	方式二
 */
public class RunnableTest {

	public static void main(String[] args) {
		TicketRunnanble tr = new TicketRunnanble();
		
		Thread t1 = new Thread(tr); 
		Thread t2 = new Thread(tr); 
		Thread t3 = new Thread(tr); 
		Thread t4 = new Thread(tr); 
		
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		t4.setName("窗口4");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}


运行发现也会出现卡死的现象，和之前一样出现一样的票卖了多次的情况。

 

加一个睡眠操作：

 

package thread2;
/**
 * 
 * @author Angus
 *	方式二
 */
public class TicketRunnanble implements Runnable {
	private int tickets = 200;
	@Override
	public void run() {

		while(true){
			
			if(tickets>0){
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+" 正在出售"+(tickets--)+"张票");
			}
		}
	}

}

 

 

 

 

 

会发现出现了负数：

 

甚至还有-2

当剩余最后一张票的时候，线程判断 >0 ，四个线程都进来了，这样就会出现负数的情况在 t--的情况下。而且在ticket--的情况下 也会出现相同票数的情况。。

 

解决：引入线程锁  synchronized

 

package thread2;

/**
 * 
 * @author Angus 
 * 			解决出现负数和相同数的方法; 
 * 			在出问题的代码中加一个锁 找问题代码： 
 * 				1 找共享数据 
 * 				2 共享数据中有没有多条语句 
 * 				3是不是在多线程中 
 * 怎么锁？ 
 * 		synchronized(锁对象)
 * 注意;多个线程必须使用同一把锁
 */
public class TicketRunnanble implements Runnable {
	private int tickets = 100;
	private Object obj = new Object();
	@Override
	public void run() {

		while (true) {
			synchronized (obj) {

				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ " 正在出售" + (tickets--) + "张票");
				}
			}
		}
	}

}


这样运行就没有问题了，不会出现负数和相同的数据了。

 

方法锁的引入：

 

package thread2;

/**
 * 
 * @author Angus synchronized(锁对象)
 * 
 *         锁对象除了object还可以试其它对象？ 结论; 同步代码锁可以试任意对象
 */
class Demo {
	// 测试发现没问题。
}

public class TicketRunnanble implements Runnable {
	private int tickets = 100;
	private Object obj = new Object();
	private Demo d = new Demo();

	@Override
	public void run() {
		int x = 0;
		while (true) {
			if (x % 2 == 0) {
				synchronized (d) {

					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ " 正在出售" + (tickets--) + "张票");
					}
				}
			} else {
				synchronized (d) {

					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ " 正在出售" + (tickets--) + "张票");
					}
				}
			}
			x++;
		}

	}
}


测试没有问题，同一个锁对象。。。把else抽取成方法测试;

 

 

package thread2;

/**
 * 
 * @author Angus synchronized(锁对象)
 * 
 *         锁对象除了object还可以试其它对象？ 结论; 同步代码锁可以试任意对象
 */
class Demo {
	// 测试发现没问题。
}

public class TicketRunnanble implements Runnable {
	private int tickets = 100;
	private Object obj = new Object();
	private Demo d = new Demo();

	@Override
	public void run() {
		int x = 0;
		while (true) {
			if (x % 2 == 0) {
				synchronized (d) {

					if (tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()
								+ " 正在出售" + (tickets--) + "张票");
					}
				}
			} else {
				check();
			}
			x++;
		}

	}

	private void check() {

		synchronized (d) {

			if (tickets > 0) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()
						+ " 正在出售" + (tickets--) + "张票");
			}
		}
	
	}
}


这样运行也没有问题，OK，线程抽取方法锁测试;

 

 

private synchronized void check() {

			if (tickets > 0) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()
						+ " 正在出售" + (tickets--) + "张票");
			}
	}

方法中加了锁，代码中就不需要加了，测试。。：

 


 

出现了一样的，因为方法锁也没有确认同一个对象，if中用的是demo对象。。

问题一：测试返现同步方法锁的对象为this对象修改代码：

 

synchronized (this)


这样就和同步方法为同一个对象，线程就没有问题了。。

 

问题二：静态方法锁的对象是？

测试返现为：

是当前类的字节码文件对象
类名.class

修改代码：

 

synchronized (TicketRunnanble.class)

 

 

 

 

 

线程的死锁：


MyLock

 

package thread2;

public class MyLock {
	public static final Object obja = new Object();
	public static final Object objb = new Object();
}


DieLock

 

 

 

 

package thread2;
/**
 * @author Angus
 * 	
 *	死锁的问题：
 *		五个人吃饭，菜齐了，一人只有一只筷子，每个人思考，把筷子借给别人，然后别人吃完自己再吃，
 *		假如五个人都饿了，都拿着自己的筷子，并且等着别人放下筷子，然后使用，但是没有一个人愿意先放下筷子
 *		所以就出现了死锁。。
 *	
 */
public class DieLock extends Thread{
	private boolean flag;
	
	public DieLock(boolean flag) {
		this.flag = flag;
	}
	@Override
	public void run() {
		if(flag){
			synchronized (MyLock.obja) {
				System.out.println("true---obja");
				//当线程d1走到这里线程2抢到了起源  线程d1需要 MyLock.objb
				synchronized (MyLock.objb) {
					System.out.println("true---objb");
				}
			}
		}else{
			synchronized (MyLock.objb) {
				System.out.println("true---objb");
				//当线程d2走到这里的时候，线程d2需要 MyLock.obja
				synchronized (MyLock.obja) {
					System.out.println("true---obja");
				}
			}
		}
		//谁也不放锁，就会造成死锁。。。。。
	}
	
}


测试DieLockDemo

 

 

package thread2;

public class DieLockDemo {

	public static void main(String[] args) {
		DieLock d1 = new DieLock(true);
		DieLock d2 = new DieLock(false);
		
		d1.start();
		d2.start();
	}

}


结果;  出现了死锁。。。。

 

 

 

线程间的通讯：

线程间的通讯：不同种类的线程对共享数据的操作功能。。。

 

 * 举例：以学生做为资源
 * 学生类
 * 设置学生类
 * 获取学生类
 * 测试类

 

Student

package thread3;

public class Student {
	String name;
	int age;
}

SetStudent

package thread3;

public class SetStudent implements Runnable {
	private Student s;
	
	public SetStudent(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		int x = 0;
		while(true){
			if(x %2 ==0){
				s.name = "呵呵1";
				s.age = 28;
			}else{
				s.name = "哈哈2";
				s.age = 11;
			}
		}
	}

}

GetStudent

package thread3;

public class GetStudent implements Runnable{
	private Student s;
	public GetStudent(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while(true){
			
			System.out.println(s.name+s.age);
		}
	}

}


StudentTest

package thread3;
/**
 * @author Angus
 *	线程间的通讯：
 *		举例：以学生做为资源
 *	学生类
 *	设置学生类
 *	获取学生类
 *	测试类
 *	
 *测试发现，出现年龄和姓名的交叉问题。。
 */
public class StudentTest {
	public static void main(String[] args) {
		Student s = new Student();
		
		SetStudent ss = new SetStudent(s);
		GetStudent gs = new GetStudent(s);
		
		Thread t1 = new Thread(ss);
		Thread t2 = new Thread(gs);
		
		t1.start();
		t2.start();
	}
}


结果：

 


测试发现，出现年龄和姓名的交叉问题。。在run方法下，线程的随机性，出现了这样的情况。。

需要同步锁解决。

 

	@Override
	public void run() {
		//t1进来
		int x = 0;
		while(true){
			synchronized (s) {
				if(x %2 ==0){
					s.name = "呵呵 ";
					s.age = 28;
				}else{
					s.name = "哈哈 ";
					s.age = 11;
				}
			}
			x++; //x=1
		}
	}

 

 

 

@Override
	public void run() {
		while(true){
			synchronized (s) {
				System.out.println(s.name+s.age);
			}
		}
	}


运行解决。。。

但是发现在控制台一打一大片一个线程的数据，能不能每个线程交叉进程呢？

线程的等待：

 

*	发现输出的内容是一大片一大片输出的，能不能一个输出后再输出另一个交叉进行呢？
 *	
 *	针对输出：
 *		判断是否有数据，有就输出，没有待设置数据
 *	针对设置：
 *		判断是否有数据，有就等待输出，否则输出
 *	等待唤醒机制;
 *		wait();  //等待
 *		notify();//唤醒


修改代码：

 

Student;

 

package thread3;

public class Student {
	String name;
	int age;
	boolean flag = false; //ture 有数据
}


SetStudent

 

 

	@Override
	public void run() {
		//t1进来
		int x = 0;
		while(true){
			synchronized (s) {
				//如果有数据等待
				if(s.flag){
					try {
						s.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				if(x %2 ==0){
					s.name = "呵呵 ";
					s.age = 28;
				}else{
					s.name = "哈哈 ";
					s.age = 11;
				}
				//修改标记
				s.flag = true;
				s.notify();
			}
			x++; //x=1
		}
	}

GetStudent

	@Override
	public void run() {
		while(true){
			synchronized (s) {
				if(!s.flag){
					try {
						s.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println(s.name+s.age);
				s.flag = false;
				s.notify();
			}
		}
	}


运行结果;全部交叉进行。。。。

 



 

线程的优先级;

PriorityDemo

 

package thread4;

public class PriorityDemo implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+"  ----"+i);
		}
	}

}


PriorityTset

package thread4;
/**
 * 线程的优先级
 * @author Angus
 *	
 *	getPriority() 返回线程的优先级。
 *	setPriority(int newPriority)  更改线程的优先级。
 *
 *	运行发现，优先级并不是每次都最先运行
 *	注意：优先级只是在一定的程度上，让线程优先级的多执行次数
 */
public class PriorityTset {

	public static void main(String[] args) {
		PriorityDemo pd = new PriorityDemo();
		
		Thread t1 = new Thread(pd);
		Thread t2 = new Thread(pd);
		Thread t3 = new Thread(pd);
		
		t1.setName("哈哈1");
		t2.setName("哈哈2");
		t3.setName("哈哈3");
		
		t1.setPriority(1); //默认5范围1-10
		t2.setPriority(5); 
		t3.setPriority(10); 
		
		System.out.println(t1.getPriority());
		System.out.println(t2.getPriority());
		System.out.println(t3.getPriority());
		
		t1.start();
		t2.start();
		t3.start();
	}

}


其它API中的方法：

 

public static void yield()暂停当前正在执行的线程对象，并执行其他线程。 

让线程更和谐一些，一般不怎么用。。。。wait线程唤醒可以替换。。

public final void join()
                throws InterruptedException等待该线程终止。 

也是加入线程，可以让一个线程加入到运行中的线程中。。。。。前提是线程启动start了。。

public final void setDaemon(boolean on)
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。 
该方法必须在启动线程前调用。 


该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。 

 



最后附上JDK使用文档API 下载

 

 

 

 

 

 

 

最后附上JDK使用文档API  下载
Angus博客
关注
专栏目录
Exception in thread "Thread-13" java.util.ConcurrentModificationException
sky_xin的专栏
11-30 947
参考：http://blog.163.com/asd_wll/blog/static/210310402011627609901/     经常我们要删除集合中的某些元素。有些可能会这么写。  Java代码   public void operate(List list){           for (Iterator it = list.iterator(); it.ha...
Java基础复习-多线程
DFGOMC的博客
12-22 162
Java基础复习-多线程 本文仅对学习过程中所缺java知识点的查缺补漏复习 多线程 程序(program)：为了完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象； 进程(process)：程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有自身的产生、存在和消亡的过程-生命周期； 程序是静态的，进程是动态的； 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域； 线程(thread)：进程可以进一步细化为线程，是一个程序内部的一条执行路径。
JavaThread 13 Lock 锁
小哞^同^学的技术博客
07-18 181
6.1 Lock 锁 6.1.1 Lock 锁 理解（ReentrantLock） 如果说 synchronized 被称为 同步锁，那么 Lock 就是比它 还要强大的 "同步锁" ！ 从JDK 5.0 开始，Java 提供了更加强大的线程同步机制 —— 通过显式定义同步锁对象来实现同步。同步锁使用 Lock 对象充当。 java.util.concurrent.locks.Lock 接口是 控制多个线程 对共享资源进行访问的工具。锁 提供了 对共享资源的独占访问。每次只能有一个 线程 对 Lo
thread13 - synchronized优化
mediocre117的博客
06-10 251
package com.neutron.t13; import java.util.concurrent.TimeUnit; /** * synchronized语句优化： * 同步代码块中的语句越少越好 */ public class T13 { int count = 0; public synchronized void run1() { //
RT-Thread-13-消息队列
u012084226的博客
06-25 115
并把消息缓存到自己的内存空间中，其他线程可以从消息队列中读取相应的消息并进行处理；RT-Thread中另一种线程间通信的方式—消息队列，它是对邮箱的拓展；消息队列能够接收来自线程或中断程序发出的。
day-13-对线程【Thread、线程创建】
liyingda_itgood的博客
11-01 222
1.线程一个线程就是一个正在运行的程序；就是程序执行的线路（路径）；如果程序中同时有两个或两个以上的程序在执行，这个程序叫做多线程程序；进程：是应用程序的载体，当软件一运行起来的时候，系统就会给这个软件创建一个新的进程。一个应用程序（软件）对应一个进程；一个进程里面可以包含多个线程，一个线程里面只能包含一个进程；好处：提高软件的运行效率（性能）； 1.1 多线程程序运行的原理在同一时刻只能有一个线程
Java期末复习||应用程序设计-多线程和泛型
08-02
在Java中，实现多线程有两种主要方式：一是通过继承`Thread`类，二是通过实现`Runnable`接口。通常推荐使用实现`Runnable`接口的方式，因为这样可以避免单继承的限制，实现更好的代码复用。 1. **多线程实现** - ...
Java基础复习
04-25
13. **多线程**：Java内置了对多线程的支持，通过Thread类或实现Runnable接口创建线程。理解和掌握线程同步机制（synchronized、wait/notify、Lock等）是解决并发问题的关键。 14. **反射机制**：Java的反射API允许...
Java基础复习-Java JavaSE 必练基础案例（CSDN@追光者♂）
最新发布
07-24
5. **多线程**：Java提供对多线程的内置支持，通过Thread类和Runnable接口实现。理解线程的生命周期、同步机制（synchronized关键字、wait()、notify()等）是并发编程的关键。 6. **网络编程**：Socket编程是Java...
JAVA基础知识复习之多线程
weixin_43689040的博客
05-13 128
继承Thread类 Thread 线程： 单线程 多线程 进程：同一个程序可以有多个进程来处理逻辑 代表计算机中的一个正在运行的应用，系统中允许多进程并发执行的 在一个进程的内部，又可以是多线程并发的 ，很多工作要同时进行 在进程中一个工作就是一个线程 ，多个工作就是多线程 ，多个工作同时进行 多线程并发。 使用资源的人多，资源锁起来，让资源排队使用， 锁定一个资源。让线程不能同时使用这...
十三 Thread的一些常用方法
weixin_30922589的博客
10-25 83
setName() : 给线程起名字。 isAlive() : 线程是否存或。 currentThread() :取得当前线程。 getId() : 取得线程的唯一标识。 转载于:https://www.cnblogs.com/liufei1983/p/9849266.html...
多线程
让代码飞~~~~~
03-26 349
一： 进程：是一个正在执行中的程序     每一个进程之星都有一个执行顺序，该顺序是一个执行路径或者叫一个控制单元  线程：就是进程中一个独立的控制单元     线程控制着进程的执行 一个进程中至少有一个线程 java VM  启动的时候会有一个进程java.exe 该进程中至少一个线程负责java程序的执行 而且这个线程的代码存在于main方法中。
Thread线程类基本使用(下)
qq_61797201的博客
07-28 1467
前一篇文章主要介绍了如何创建新线程和如何查看Java进程中的线程信息等知识，这篇文章接着介绍关于Thread的一些构造方法及方法，这篇文章会用到。
Thread详解13：ReentrantLock的用法（一）
cds86333774的博客
03-31 4957
Java里面提供了比synchronized更加灵活丰富的锁机制，它们有一个共同的接口Lock，我们先来学习这个接口，了解其协议和功能。下面是JDK文档，总结得非常精炼，包含的知识点非常多，所以一开始可能看不懂，不过没关系，后面一点点弄懂。public interface LockLock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具
xxl job踩坑 Exception in thread “Thread-13“ java.net.BindException: Address already in use: bind
afq18269003781的博客
02-08 1512
xxlJob执行器启动，报错 解决方案： 1.XxlJobSpringExecutor 注入只写@bean就行 2.xxl.job.executor.port 配置小于10000（实测出来的，官网文档没说明，具体原因没深究）
A WebView method was called on thread".....”All WebView methods must be called on the same thread
记录生活中的点滴美好，活在当下！
01-13 1274
RuntimeException: java.lang.Throwable: A WebView method was called on thread ‘OkHttp http://www.zhidianbao.cn/…’. All WebView methods must be called on the same thread. (Expected Looper Looper (main, ...
A WebView method was called on thread ‘Thread-15‘
zhaojunhua_123的博客
11-04 1844
完整的错误日志如下： 2021-11-04 18:05:00.826 7793-8402/com.cloudmind.vegarena E/AndroidRuntime: FATAL EXCEPTION: Thread-15 Process: com.cloudmind.vegarena, PID: 7793 java.lang.RuntimeException: java.lang.Throwable: A WebView method was called on thread '.
Thread创建线程
qq_56967325的博客
08-07 1362
创建线程 1.继承Thread类创建线程 public class MyThread extends Thread{ public void run(){ System.out.println("这里运行线程代码"); } public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); } } 2.实现Runna
Android异常解决--A WebView method was called on thread 'JavaBridge'. All WebView methods must be called
Angus博客
03-14 2179
Android异常解决--A WebView method was called on thread 'JavaBridge'. All WebView methods must be called android端调用js. 使用webView.loadUrl("javascript: alert(" + data +")"); 出现异常.异常log如下：[html] view plain co...
Java多线程复习：线程创建与调度
"E05_多线程复习.pdf 是一份关于Java多线程的复习资料，涵盖了进程、线程的基本概念，线程的创建方式，线程调度，以及线程安全和JUC编程的相关知识点。" 在计算机系统中，**进程**是一个正在执行的应用程序，它拥有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值