Thread
多线程的创建方式
- 方式一：继承于Thread类
1.创建一个继承于Thread的子类
2.重写Thread类的run()方法
3.创建Thread子类的对象
4.通过此对象调用start()，作用：启动当前线程、调用当前线程的run()
注意：不能直接通过调用run()方法启动线程、如果要再启动一个线程实现多功能，则需要再使用方式一，再调用start()方法
public class Example1 extends Thread{
private static int ticket = 100;
private static Object object = new Object();
@Override
public void run() {
while (true) {
synchronized (object) {
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "票号为：" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
class Main1 {
public static void main(String[] args) {
Example1 example1 = new Example1();
Example1 example2 = new Example1();
Example1 example3 = new Example1();
example1.start();
example2.start();
example3.start();
}
}
- 方式二：实现Runnable接口
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()
class Example2 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true) {
synchronized (this) { //使用Runnable时可以考虑使用this为同步监视器
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "票号为：" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
class Main2 {
public static void main(String[] args) {
Example2 example1_2 = new Example2();
Thread t1 = new Thread(example1_2);
t1.setName("线程一");
t1.start();
Thread t2 = new Thread(example1_2);
t2.setName("线程二");
t2.start();
Thread t3 = new Thread(example1_2);
t3.setName("线程三");
t3.start();
}
}
- 方式三：实现Callable接口，见CallableTest类
//1.创建一个实现Callable的实现类
public class CallableTest 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);
sum += i;
}
}
return sum;
}
}
class Test {
public static void main(String[] args) {
//3.创建实现Callable接口实现类的对象
CallableTest callableTest = new CallableTest();
//4.将次Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(callableTest);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，调用start()方法
new Thread(futureTask).start();
//获取Callable中call的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
try {
Object sum = futureTask.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
- 方式四：使用线程池
* 优先选择实现Runnable接口的方式
* 没有单继承的局限性
* 适合处理多个线程共享数据的情况
Thread类的方法
* Thread类的有关方法：
* 1. start()：启动当前线程，调用当前线程的run()
* 2. run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
* 3. currentThread()：静态方法，返回执行当前代码的线程
* 4. getName()：获取当前线程的名字
* 5. setName()：设置当前线程名字
* 6. yield()：释放当前的CPU执行权，下一次执行仍然有可能获得执行权
* 7. join()：在线程a中调用线程b的join()，此时线程a就暂时停止执行（阻塞状态），知道线程b执行完以后线程a再执行
* 8. stop()：强制结束线程，已过时
* 9. sleep("时间（毫秒）")：让当前线程指定一段时间执行一次，在指定时间内此线程不执行（阻塞状态）
* 10. isAlive()：判断当前线程是否存活
线程的优先级，生命周期，线程的通信
线程的优先级：
- MAX_PRIORITY：10（最大优先级）
MIN_PRIORITY：1（最小优先级）
NORM_PRIORITY：5（默认优先级）
-
2.设置优先级
getPriority()：获取线程的优先级
setPriority(int p)：设置线程的优先级 -
3.不一定高优先级的线程就会先执行，只是比低优先级的执行概率高一些
-
线程的生命周期：
新建-（调用start()方法）-就绪-（获取CPU执行权）-运行-（执行完run()、调用stop()、出现异常）-死亡
新建-（调用start()方法）-就绪-（获取CPU执行权）-运行-（sleep()，等待同步锁，join()，wait()，suspend()）-阻塞-（sleep()时间到，join()结束，获取同步锁，notify()/notifyAll()，resume()）-就绪-（获取CPU执行权）-运行（执行完run()、调用stop()、出现异常）-死亡
线程的通信：
- 涉及到的三个方法：wait():一旦执行此方法，当前线程进入阻塞状态，并释放同步监视器
notify():唤醒被wait的一个线程，如果有多个线程被wait则唤醒优先级高的
notifyAll():换醒所有被wait的线程 -
这三个方法必须使用在同步代码块或者是同步方法中，并且必须由同步监视器调用 -
代码解释见Communication类
sleep()和wait()的异同
* 相同点：一旦执行方法，都可以使当前的线程进入阻塞状态
* 不同：声明位置不同，Thread类中声明sleep(),Object类中声明wait()；
* 调用要求不同，sleep()可以在任何需要场景下使用。wait()必须在同步代码块或同步方法中使用
* 如果都在同步代码块或同步方法中使用，wait()会释放锁，sleep()不会释放锁
线程安全问题
* 方式一：同步代码块
* synchronized(同步监视器){
* //需要被同步的代码
* }
* 说明：1.操作共享数据的代码即为需要被同步的代码。2.共享数据：多个线程共同操作的变量。3.同步监视器：简称锁；任何一个类的对象都可以充当锁，要求多个线程用同一把锁
* 代码解释见Example1和Example2
* 方式二：同步方法
* 1.非静态同步方法，同步监视器是this
* 2.静态同步方法，同步监视器是当前类本身
* 代码解释见Example4
* 方式三：Lock锁
* 见Lock类，需要手动启动和结束同步
public class Lock implements Runnable{
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
//调用锁定方法
lock.lock();
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + ticket);
ticket--;
} else {
break;
}
} finally{
//调用解锁方法
lock.unlock();
}
}
}
}
class TestLock{
public static void main(String[] args) {
Lock lock = new Lock();
Thread t1 = new Thread(lock);
Thread t2 = new Thread(lock);
Thread t3 = new Thread(lock);
t1.setName("线程一");
t2.setName("线程二");
t3.setName("线程三");
t1.start();
t2.start();
t3.start();
}
}
生产消费例题
class Clerk{
private int productCount = 0;
public synchronized void producter() {
if (productCount < 20){
productCount ++;
System.out.println(Thread.currentThread().getName() + "生产" + productCount);
notify();
} else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void consume(){
if (productCount > 0) {
productCount --;
System.out.println(Thread.currentThread().getName() + "消费" + productCount);
notify();
} else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//生产者
class Productor implements Runnable{
private Clerk clerk;
public Productor(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
while (true){
try {
Thread.sleep(8);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.producter();
}
}
}
class Customer implements Runnable{
private Clerk clerk;
public Customer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
while (true){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consume();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Productor productor = new Productor(clerk);
Customer customer = new Customer(clerk);
Thread t1 = new Thread(productor);
Thread t2 = new Thread(customer);
t1.setName("生产者");
t2.setName("消费者");
t1.start();
t2.start();
}
}
扫一扫
2236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
