Java 多线程笔记，java 自学视频免费
for (int i=0;i<1000;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
/**
方式二：
匿名子类创建，针对只调用一次的线程
*/
public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1();
myThread1.start();
MyThread2 myThread2 = new MyThread2();
myThread2.start();
//通过匿名子类实现调用：特点只需要调用一次的子线程
new Thread(){
@Override
public void run() {
for (int i=0;i<1000;i++){
if (i%3==0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName()+"***"+i);
}
}
}
}
###实现 Runnable 接口
package com.atguigu.juc.runnable;
/**
创建多线程方式 Runnable
1.创建一个实现 Runnable 接口的类
2.实现类去实现 Runnable 中的抽象方法: run( )
3.创建实现类的对象
4、将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象
5，通过 Thread 类的对象调用 start()
*/
public class TestThread {
public static void main(String[] args) {
//3.创建实现类的对象
MyThread myThread = new MyThread();
//4、将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象
Thread t1 = new Thread(myThread);
//5，通过 Thread 类的对象调用 start()
t1.start();
}
}
//1.创建一个实现 Runnable 接口的类
class MyThread implements Runnable{
//2.实现类去实现 Runnable 中的抽象方法: run( )
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(i);
}
}
}
}
线程常见方法
package com.atguigu.juc.tset01;
/**
1.yield():释放当前 cpu 的执行权
2.start():启动当前线程;调用当前线程的 run()
3.run():通常需要重写 Thread 类中的此方法，将创建的线程要执行的操作声明在此方法中
4.getName()∶获取当前线程的名字
5.setName():设置当前线程的名字
6.currentThread():静态方法，返回执行当前代码的线程
7.join():在线程 a 中调用线程 b 的 join(),此时线程 a 就进入阻塞状态，直到线程 b 完全执行完以后，线程 a 才结束阻塞状态。
8.sleep():让当前线程"睡眠”指定的毫秒。在指定的毫秒时间内，当前线程是阻塞状态。
*/
public class MyThreatTest {
public static void main(String[] args) {
TestMyThread t1 = new TestMyThread();
t1.start();
new Thread(){
@Override
public void run(){
for (int i=0;i<100;i++){
if (i%2==0){
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "子线程" + i);
yield();
}
}
}
}.start();
for (int i=0;i<100;i++){
if (i%3==0){
System.out.println(Thread.currentThread().getName() + "main 方法" + i);
}
if (i==20){
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class TestMyThread extends Thread{
@Override
public void run(){
for (int i=0;i<100;i++){
if (i%5==0){
System.out.println(Thread.currentThread().getName() + "2222222222222 子线程" + i);
}
}
}
}
synchronized 锁机制
一把锁只能同时被一个线程获取，没有获得锁的线程只能等待；
每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class 以及 synchronized 修饰的是 static 方法的时候，所有对象公用同一把锁
synchronized 修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁
##同步代码—Runnable 接口方式
/**
*方式一:同步代码块
synchronized(同步监视器){
}
说明:
1.操作共享数据的代码，即为需要被同步的代码
2.共享数据:多个线程共同操作的变量
3.同步监视器，俗称:锁。任何一个类的对象都可以作为索
4.在 Java 中，我们通过同步机制，来解决线程的安全问题。
补充:在实现 Runnable 接口创建多线程的方式中，我们可以考虑使用 this 充当同步监视器。
方式二:同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
5.同步的方式，解决了线程的安全问题。---好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。
*/
public class WindowToRunnable {
public static void main(String[] args) {
Window2 window2 = new Window2();
Thread t1 = new Thread(window2);
Thread t2 = new Thread(window2);
Thread t3 = new Thread(window2);
t1.setName("窗口 1");
t2.setName("窗口 2");
t3.setName("窗口 3");
t1.start();
t2.start();
t3.start();
}
}
class Window2 implements Runnable{
//这里不用加 static,因为调用的对象只有一个
private int ticket=100;
@Override
public void run() {
while (true) {
synchronized (this.getClass()){
if (ticket > 0) {
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(Thread.currentThread
().getName() + "买票,票号:" + ticket);
ticket--;
}
}
}
}
}
package com.atguigu.juc.bookPage;
/**
使用同步方法解决实现 Runnable 接口的线程安全问题
关于同步方法的总结:
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2．非静态的同步方法，同步监视器是: this
静态的同步方法，同步监视器是:当前类本身
*/
public class WindowExtSynn {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName("窗口 1");
w2.setName("窗口 2");
w3.setName("窗口 3");
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show() {
if (ticket>0){
System.out.println(Thread.currentThread().getName()+":买票：票号为"+ticket);
ticket--;
}
}
}
##同步方法—继承方法
package com.atguigu.juc.bookPage;
/**
使用同步方法解决实现 Runnable 接口的线程安全问题
关于同步方法的总结:
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2．非静态的同步方法，同步监视器是: this
静态的同步方法，同步监视器是:当前类本身
*/
public class WindowExtSynn {
public static void main(String[] args) {
Window4 w1 = new Window4();
Window4 w2 = new Window4();
Window4 w3 = new Window4();
w1.setName("窗口 1");
w2.setName("窗口 2");
w3.setName("窗口 3");
w1.start();
w2.start();
w3.start();
}
}
class Window4 extends Thread{
private static int ticket=100;
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show() {
if (ticket>0){
System.out.println(Thread.currentThread().getName()+":买票：票号为"+ticket);
ticket--;
}
}
}
##死锁
示例：两个线程都拿到第一层锁的 key，然后都需要第二层锁的 key，但 key 在对方手中，而方法没有执行完，都不可能释放 key，互相僵持。
import static java.lang.Thread.sleep;
public class TestSyn {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized (s1) {
s1.append("a");
s2.append("1");
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2) {
s1.append("c");
s2.append("3");
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1) {
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
##Lock 锁机制
import java.util.concurrent.locks.ReentrantLock;
/**
解决线程安全问题的方式三: Lock 锁--- JDK5.0 新增
synchronized 与 Lock 的异同?
相同:二者都可以解决线程安全问题
不同: synchronized 机制在执行完相应的同步代码以后，自动的释放同步监视器
*/
public class LockTest {
public static void main(String[] args) {
Window6 window6 = new Window6();
Thread t1 = new Thread(window6);
Thread t2 = new Thread(window6);
Thread t3 = new Thread(window6);
t1.setName("窗口 1");
t2.setName("窗口 2");
t3.setName("窗口 3");
t1.start();
t2.start();
t3.start();
}
}
class Window6 implements Runnable{
private int ticker=100;
private ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
while (true){
还未添加个人签名 2021.11.08 加入
还未添加个人简介
评论