diff --git a/ylong_runtime/benches/ylong_tokio_signal.rs b/ylong_runtime/benches/ylong_tokio_signal.rs
index 34f10b50a622287127cf2265b9f732a708dbf325..1d261c3b70518d7b267acc2c980c3ec5d8444e95 100644
--- a/ylong_runtime/benches/ylong_tokio_signal.rs
+++ b/ylong_runtime/benches/ylong_tokio_signal.rs
@@ -42,7 +42,9 @@ macro_rules! tokio_signal_multi_thread_task {
                     }));
                 }
                 while num.load(Acquire) < 10 {}
-                unsafe { libc::raise($sig) };
+                unsafe {
+                    libc::kill(libc::getpid(), $sig);
+                }
                 for handler in handlers {
                     let _ = runtime.block_on(handler).unwrap();
                 }
@@ -62,7 +64,9 @@ macro_rules! tokio_signal_single_thread_task {
                 let handler = runtime.spawn(async move {
                     let mut stream = tokio_signal($kind).unwrap();
                     for _ in 0..$num {
-                        unsafe { libc::raise($sig) };
+                        unsafe {
+                            libc::kill(libc::getpid(), $sig);
+                        }
                         stream.recv().await;
                     }
                 });
@@ -91,7 +95,9 @@ macro_rules! ylong_signal_multi_thread_task {
                     }));
                 }
                 while num.load(Acquire) < 10 {}
-                unsafe { libc::raise($sig) };
+                unsafe {
+                    libc::kill(libc::getpid(), $sig);
+                }
                 for handler in handlers {
                     let _ = runtime.block_on(handler).unwrap();
                 }
@@ -111,7 +117,9 @@ macro_rules! ylong_signal_single_thread_task {
                 let handler = runtime.spawn(async move {
                     let mut stream = ylong_signal($kind).unwrap();
                     for _ in 0..$num {
-                        unsafe { libc::raise($sig) };
+                        unsafe {
+                            libc::kill(libc::getpid(), $sig);
+                        }
                         stream.recv().await;
                     }
                 });
diff --git a/ylong_runtime/examples/ylong_runtime_signal.rs b/ylong_runtime/examples/ylong_runtime_signal.rs
index 002137df253e99be7af8fc36ccb0b127e6e09383..dcb1e2435987dd34b80817298fb96d5656d7e6eb 100644
--- a/ylong_runtime/examples/ylong_runtime_signal.rs
+++ b/ylong_runtime/examples/ylong_runtime_signal.rs
@@ -41,7 +41,9 @@ fn run_multi_thread_signal() {
         }));
     }
     while num.load(Acquire) < 10 {}
-    unsafe { libc::raise(libc::SIGCHLD) };
+    unsafe {
+        libc::kill(libc::getpid(), libc::SIGCHLD);
+    }
     for handle in handles {
         let _ = ylong_runtime::block_on(handle);
     }
diff --git a/ylong_runtime/src/signal/unix/mod.rs b/ylong_runtime/src/signal/unix/mod.rs
index 56d14d1af9de8bb21f61b88bfde090f782f236c1..4b0b235fc28186ff51c04602a9ba4a1d0d324cbb 100644
--- a/ylong_runtime/src/signal/unix/mod.rs
+++ b/ylong_runtime/src/signal/unix/mod.rs
@@ -442,57 +442,79 @@ mod tests {
         let mut handles = Vec::new();
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::alarm()).unwrap();
-            unsafe { libc::raise(libc::SIGALRM) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGALRM);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::child()).unwrap();
-            unsafe { libc::raise(libc::SIGCHLD) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGCHLD);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::hangup()).unwrap();
-            unsafe { libc::raise(libc::SIGHUP) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGHUP);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::interrupt()).unwrap();
-            unsafe { libc::raise(libc::SIGINT) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGINT);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::io()).unwrap();
-            unsafe { libc::raise(libc::SIGIO) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGIO);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::pipe()).unwrap();
-            unsafe { libc::raise(libc::SIGPIPE) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGPIPE);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::quit()).unwrap();
-            unsafe { libc::raise(libc::SIGQUIT) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGQUIT);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::terminate()).unwrap();
-            unsafe { libc::raise(libc::SIGTERM) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGTERM);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::user_defined1()).unwrap();
-            unsafe { libc::raise(libc::SIGUSR1) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGUSR1);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::user_defined2()).unwrap();
-            unsafe { libc::raise(libc::SIGUSR2) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGUSR2);
+            }
             signal.recv().await;
         }));
         handles.push(crate::spawn(async move {
             let mut signal = signal(SignalKind::window_change()).unwrap();
-            unsafe { libc::raise(libc::SIGWINCH) };
+            unsafe {
+                libc::kill(libc::getpid(), libc::SIGWINCH);
+            }
             signal.recv().await;
         }));
 
diff --git a/ylong_runtime/tests/signal.rs b/ylong_runtime/tests/signal.rs
index 0f91a1c3edc2f74a09bb7020d9af342a1b2a489c..71484a20254b4459ad8713bc9495aeae944055f3 100644
--- a/ylong_runtime/tests/signal.rs
+++ b/ylong_runtime/tests/signal.rs
@@ -34,7 +34,9 @@ mod linux_test {
         let handle = ylong_runtime::spawn(async move {
             let mut stream = signal(SignalKind::alarm()).unwrap();
             for _ in 0..10 {
-                unsafe { libc::raise(libc::SIGALRM) };
+                unsafe {
+                    libc::kill(libc::getpid(), libc::SIGALRM);
+                }
                 stream.recv().await;
             }
         });
@@ -60,7 +62,9 @@ mod linux_test {
             }));
         }
         while num.load(Acquire) < 10 {}
-        unsafe { libc::raise(libc::SIGCHLD) };
+        unsafe {
+            libc::kill(libc::getpid(), libc::SIGCHLD);
+        }
         for handle in handles {
             let _ = ylong_runtime::block_on(handle);
         }
@@ -78,7 +82,9 @@ mod linux_test {
         let handle = ylong_runtime::spawn(async move {
             let mut stream = signal(SignalKind::hangup()).unwrap();
             for _ in 0..10 {
-                unsafe { libc::raise(libc::SIGHUP) };
+                unsafe {
+                    libc::kill(libc::getpid(), libc::SIGHUP);
+                }
                 poll_fn(|cx| stream.poll_recv(cx)).await;
             }
         });
@@ -104,7 +110,9 @@ mod linux_test {
             }));
         }
         while num.load(Acquire) < 10 {}
-        unsafe { libc::raise(libc::SIGIO) };
+        unsafe {
+            libc::kill(libc::getpid(), libc::SIGIO);
+        }
         for handle in handles {
             let _ = ylong_runtime::block_on(handle);
         }
diff --git a/ylong_signal/tests/signal.rs b/ylong_signal/tests/signal.rs
index 41b74b6b141fa02cac2fcbc5a374b6fff84053fa..e01c0e0ebd69b84894bf192c956aeac613b78566 100644
--- a/ylong_signal/tests/signal.rs
+++ b/ylong_signal/tests/signal.rs
@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::hint::spin_loop;
 use std::io;
 use std::mem::MaybeUninit;
 use std::os::raw::c_int;
@@ -67,11 +68,23 @@ fn sdv_signal_register_succeed() {
     assert!(res.is_ok());
     assert_eq!(value.load(Ordering::Relaxed), 0);
 
-    unsafe { libc::raise(libc::SIGINT) };
+    unsafe {
+        libc::kill(libc::getpid(), libc::SIGINT);
+    }
+
+    while value.load(Ordering::Relaxed) == 0 {
+        spin_loop();
+    }
     assert_eq!(value.load(Ordering::Relaxed), 1);
+
     assert_eq!(value2.load(Ordering::Relaxed), 10);
+    unsafe {
+        libc::kill(libc::getpid(), libc::SIGTERM);
+    }
 
-    unsafe { libc::raise(libc::SIGTERM) };
+    while value2.load(Ordering::Relaxed) == 10 {
+        spin_loop();
+    }
     assert_eq!(value.load(Ordering::Relaxed), 1);
     assert_eq!(value2.load(Ordering::Relaxed), 20);
 
@@ -87,7 +100,12 @@ fn sdv_signal_register_succeed() {
     };
     assert!(res.is_ok());
 
-    unsafe { libc::raise(libc::SIGTERM) };
+    unsafe {
+        libc::kill(libc::getpid(), libc::SIGTERM);
+    }
+    while value2.load(Ordering::Relaxed) == 20 {
+        spin_loop();
+    }
     assert_eq!(value2.load(Ordering::Relaxed), 40);
 
     let res = ylong_signal::deregister_signal_hook(libc::SIGTERM);
@@ -168,17 +186,23 @@ fn sdv_signal_register_with_old() {
     assert!(res.is_ok());
 
     unsafe {
-        libc::raise(libc::SIGINT);
+        libc::kill(libc::getpid(), libc::SIGINT);
     }
 
     let global = Global::get_instance();
+    while global.value.load(Ordering::Relaxed) == 0 {
+        spin_loop();
+    }
     assert_eq!(global.value.load(Ordering::Relaxed), 2);
 
     let res = ylong_signal::deregister_signal_action(libc::SIGINT);
     assert!(res.is_ok());
 
     unsafe {
-        libc::raise(libc::SIGINT);
+        libc::kill(libc::getpid(), libc::SIGINT);
+    }
+    while global.value.load(Ordering::Relaxed) == 2 {
+        spin_loop();
     }
     assert_eq!(global.value.load(Ordering::Relaxed), 3);
     let res = ylong_signal::deregister_signal_hook(libc::SIGINT);
@@ -227,19 +251,19 @@ fn sdv_signal_register_multi() {
                 assert_eq!(data, 100 + i);
             })
         };
-        std::thread::spawn(move || {
-            unsafe { libc::raise(libc::SIGCHLD) };
+        std::thread::spawn(move || unsafe {
+            libc::kill(libc::getpid(), libc::SIGCHLD);
         });
         assert!(res.is_ok());
         unsafe {
-            libc::raise(libc::SIGCHLD);
+            libc::kill(libc::getpid(), libc::SIGCHLD);
         }
 
         let res = ylong_signal::deregister_signal_action(libc::SIGCHLD);
         assert!(res.is_ok());
 
         unsafe {
-            libc::raise(libc::SIGCHLD);
+            libc::kill(libc::getpid(), libc::SIGCHLD);
         }
     }
 }