Pause and resume execution of stored procedure There are two processes(p1, p2) that may run simultaneously. p2 is a scheduled execution of SPROC while p1 consists of a group of stored procedures that is triggered on the request.
Execution of p1 while p2 is in progress can create issues. Only one should run at a time.
There are three ways to solve this problem

When p1 starts check whether p2 is in progress and wait until it completes. p2 can run for more than a day and it might not be a preferable solution
Kill p2, complete p1 and then restart p2. Killing and restarting p2 isn't safe due to nature of the sproc
pause p2 and resume p2 when p1 completes

Questions
1. How can I search and stop store procedure being executed?
2. Is there any way I can pause and resume a stored procedure that is being executed?
There's no clean way to just pause and resume a stored procedure, but you can have it sleep for a fixed period of time using WAITFOR DELAY 'XX:YY:ZZ' (where X is replaced with hours, Y minutes, and Z seconds for how long you want the thread to sleep).
It really depends on what p2 is doing and if there's multiple batches of queries you can break up with a check for if p1 is running. If p2 is just one single long running query then you won't be able to pause it when p1 starts, you'd only be able to make p1 wait until p2 was finished. (In this case you shouldn't have a single query running as long as a day though, so I'd recommend optimizing p2 anyway.)
If you do have a way to break up the queries in p2 then you can periodically check if p1 is running between each batch of queries, use a WHILE loop and the aforementioned WAITFOR DELAY to sleep the thread (whatever time  amount is acceptable to you) of p2, checking if p1 is done running on each iteration of the WHILE loop.
I don't think there's a perfect solution if you're trying to avoid any overlap, but if some overlap of the jobs is ok then you should be able to rig something with the above up.
You might be able to help prevent any data overlap (at the cost of potentially making p1 wait a mininal amount of time) by using transactions around each batch of queries in p2 that way p1 will have to wait until p2 finishes it's active transaction. If you want to avoid overlap for performance reasons instead, then you'll need to implement a check system in p1 as well to loop and sleep while waiting on p2 to finish it's current query batch before it sleeps itself once it checks p1 is now running.