Unable to identify deadlock

In my experience, the main source of deadlocks is locking two primitives at the same time. For example:

Thread 1:
 lock A
 lock B
 ...
 unlock B
 unlock A

Thread 2:
 lock B
 lock A
 ...
 unlock A
 unlock B

If both threads start more-or-less at the same time, thread 1 may lock A and thread 2 may lock B, and then... deadlock!

If you cannot avoid locking both objects, the obvious workaround is to always lock them in the same order: first A, then B. The unlock order is not as important.

In your code, there are two places where you have more than one object locked at the same time:

1. The main thread always locks the array first and then every client inside in order. This cannot cause a deadlock because the only other place where array is locked is in the last line client_arr_c.lock().push(clientc) and no other locks are held there.
2. The thread that dequeues requests locks the current client AND the requester client. Here lies the problem!

Rewriting that code reveals another issue: there is a race between is_empty() and pop().unwrap(). In between these two, another thread may enter and empty the queue. When you do the pop().unwrap() you will panic (note that the client lock does not protect the queue).

The race popping the queue is easy to fix:

let req = match req_qc.pop() {
    Err(_) => continue,
    Ok(x) => x,
};

About the locking of both clients, since you know what file the request wants, you could lock the current client, copy the file, unlock the client, then lock the requester, paste the file and unlock the requester. The locks don't overlap, no problem.

I guess that your real code does more than setting a 1, so that may not be feasible or optimal. If you really need both clients locked at the same time. you can for example compare the client ids and always lock the lower id first and the greater id last. Since the id is a usize that is Copy you can keep a copy outside of the clients: the id that owns the thread may be a local variable, and that of the requester may be in an extra field in the signal struct.

struct ReadySignal {
    client_id: usize, //same as client.id, but unlocked
    client:  Arc<Mutex<Client>>,
    section: usize,
}

Now when you want to lock both clients, you do:

let (clientc, mut req_client) = match client_id.cmp(&req.client_id) {
    std::cmp::Ordering::Less => {
        let a = clientc.lock();
        let b =  req.client.lock();
        (a, b)
    }
    std::cmp::Ordering::Greater => {
        let b =  req.client.lock();
        let a = clientc.lock();
        (a, b)
    }
    std::cmp::Ordering::Equal => {
        req_qc.push(req);
        continue;
    }
};

Do not forget what to do if the client is the same. Your original code sidestepped the issue by checking that the requested piece must is available before locking the second one, but here I have to lock both at the same time, so I cannot check that. Instead, if both clients are the same just repush and repeat.

There is a bit of rework here and there to make the borrow checker happy, and there are some clear pending optimizations, but this code seems to work fine (playground).

use std::thread;
use std::time::{Duration};
use std::sync::Arc;
use crossbeam::queue::SegQueue;
use parking_lot::{Mutex, MutexGuard};

struct ReadySignal {
    client_id: usize,
    client:  Arc<Mutex<Client>>,
    section: usize,
}

struct Client {
    id:      usize,
    file:    Vec<usize>,
}

fn main() {
    let max_clients = 10;
    let file_size = 1000;
    let req_q = Arc::new(SegQueue::new());
    let v: Vec<Arc<Mutex<Client>>> = Vec::new();
    let client_arr = Arc::new(Mutex::new(v));
    let client_arr_c = Arc::clone(&client_arr);
    thread::spawn(move || {
        loop {
            thread::sleep(Duration::from_millis(10));
            let mut display = String::new();
            let client_arr_c = client_arr_c.lock();
            for (_ii, i) in client_arr_c.iter().enumerate() {

                let client = i.lock();
                let total = client.file.len();
                let mut done = 0;
                for j in client.file.iter() {
                    if *j == 1 {
                        done += 1;
                    }
                }
                let percentage = (done as f64/total as f64) * 100.0;
                let client_per: String = format!("Client {}: {:.2}%\n", client.id, percentage);
                MutexGuard::unlock_fair(client);
                display += &client_per;
            }
            MutexGuard::unlock_fair(client_arr_c);
            println!("\x1B[2J\x1B[1;1H{}",display);
            
        }
    });
    let client_arr_c = Arc::clone(&client_arr);
    std::thread::spawn(move || {
        for i in 0..max_clients {
            thread::sleep(Duration::from_millis(1000));
            let mut file_init = 0;
            if i == 0 {
                file_init = 1;
            }
            let client_id = i + 1;
            let client = Arc::new(Mutex::new(Client{
                id: client_id,
                file: vec![file_init;file_size],
            }));
            let clientc = Arc::clone(&client);
            let req_qc = Arc::clone(&req_q);
            thread::spawn(move || {
                for j in 0..file_size {
                    thread::sleep(Duration::from_millis(10));
                    let clientcc = clientc.lock();
                    if clientcc.file[j] == 0 {
                        let req = ReadySignal{
                            client_id,
                            client: Arc::clone(&clientc),
                            section: j,
                        };
                        MutexGuard::unlock_fair(clientcc);
                        req_qc.push(req);
                        continue;
                    }
                    
                }
            });
            let clientc = Arc::clone(&client);
            let req_qc = Arc::clone(&req_q);
            thread::spawn(move || {
                loop {
                    thread::sleep(Duration::from_millis(20));
                    let req = match req_qc.pop() {
                        Err(_) => continue,
                        Ok(x) => x,
                    };
                    let (clientc, mut req_client) = match client_id.cmp(&req.client_id) {
                        std::cmp::Ordering::Less => {
                            let a = clientc.lock();
                            let b =  req.client.lock();
                            (a, b)
                        }
                        std::cmp::Ordering::Greater => {
                            let b =  req.client.lock();
                            let a = clientc.lock();
                            (a, b)
                        }
                        std::cmp::Ordering::Equal => {
                            req_qc.push(req);
                            continue;
                        }
                    };
                    if clientc.file[req.section] == 1 {
                        req_client.file[req.section] = 1;
                        MutexGuard::unlock_fair(req_client);
                        MutexGuard::unlock_fair(clientc);
                    } else {
                        MutexGuard::unlock_fair(req_client);
                        MutexGuard::unlock_fair(clientc);
                        req_qc.push(req);
                    }
                }
            });
            let clientc = Arc::clone(&client);
            client_arr_c.lock().push(clientc);
        }
    });
    loop {
        thread::sleep(Duration::from_millis(1000));
    }
}

Also, I've added a sleep in the empty loop at the end of the main thread to stop it from eating 100% of one CPU core.